packages feed

gi-gio 0.2.46.10 → 0.2.46.12

raw patch · 349 files changed

+86948/−5972 lines, 349 filesdep ~gi-glibdep ~gi-gobjectdep ~haskell-gi-base

Dependency ranges changed: gi-glib, gi-gobject, haskell-gi-base

Files

GI/Gio.hs view

file too large to diff

+ GI/Gio/Callbacks.hs view
@@ -0,0 +1,1465 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Callbacks+    ( ++ -- * Signals+-- ** ActionEntryActivateFieldCallback+    ActionEntryActivateFieldCallback        ,+    ActionEntryActivateFieldCallbackC       ,+    actionEntryActivateFieldCallbackClosure ,+    actionEntryActivateFieldCallbackWrapper ,+    mkActionEntryActivateFieldCallback      ,+    noActionEntryActivateFieldCallback      ,+++-- ** ActionEntryChangeStateFieldCallback+    ActionEntryChangeStateFieldCallback     ,+    ActionEntryChangeStateFieldCallbackC    ,+    actionEntryChangeStateFieldCallbackClosure,+    actionEntryChangeStateFieldCallbackWrapper,+    mkActionEntryChangeStateFieldCallback   ,+    noActionEntryChangeStateFieldCallback   ,+++-- ** AsyncReadyCallback+    AsyncReadyCallback                      ,+    AsyncReadyCallbackC                     ,+    asyncReadyCallbackClosure               ,+    asyncReadyCallbackWrapper               ,+    mkAsyncReadyCallback                    ,+    noAsyncReadyCallback                    ,+++-- ** BusAcquiredCallback+    BusAcquiredCallback                     ,+    BusAcquiredCallbackC                    ,+    busAcquiredCallbackClosure              ,+    busAcquiredCallbackWrapper              ,+    mkBusAcquiredCallback                   ,+    noBusAcquiredCallback                   ,+++-- ** BusNameAcquiredCallback+    BusNameAcquiredCallback                 ,+    BusNameAcquiredCallbackC                ,+    busNameAcquiredCallbackClosure          ,+    busNameAcquiredCallbackWrapper          ,+    mkBusNameAcquiredCallback               ,+    noBusNameAcquiredCallback               ,+++-- ** BusNameAppearedCallback+    BusNameAppearedCallback                 ,+    BusNameAppearedCallbackC                ,+    busNameAppearedCallbackClosure          ,+    busNameAppearedCallbackWrapper          ,+    mkBusNameAppearedCallback               ,+    noBusNameAppearedCallback               ,+++-- ** BusNameLostCallback+    BusNameLostCallback                     ,+    BusNameLostCallbackC                    ,+    busNameLostCallbackClosure              ,+    busNameLostCallbackWrapper              ,+    mkBusNameLostCallback                   ,+    noBusNameLostCallback                   ,+++-- ** BusNameVanishedCallback+    BusNameVanishedCallback                 ,+    BusNameVanishedCallbackC                ,+    busNameVanishedCallbackClosure          ,+    busNameVanishedCallbackWrapper          ,+    mkBusNameVanishedCallback               ,+    noBusNameVanishedCallback               ,+++-- ** CancellableSourceFunc+    CancellableSourceFunc                   ,+    CancellableSourceFuncC                  ,+    cancellableSourceFuncClosure            ,+    cancellableSourceFuncWrapper            ,+    mkCancellableSourceFunc                 ,+    noCancellableSourceFunc                 ,+++-- ** DBusInterfaceGetPropertyFunc+    DBusInterfaceGetPropertyFunc            ,+    DBusInterfaceGetPropertyFuncC           ,+    dBusInterfaceGetPropertyFuncClosure     ,+    dBusInterfaceGetPropertyFuncWrapper     ,+    mkDBusInterfaceGetPropertyFunc          ,+    noDBusInterfaceGetPropertyFunc          ,+++-- ** DBusInterfaceMethodCallFunc+    DBusInterfaceMethodCallFunc             ,+    DBusInterfaceMethodCallFuncC            ,+    dBusInterfaceMethodCallFuncClosure      ,+    dBusInterfaceMethodCallFuncWrapper      ,+    mkDBusInterfaceMethodCallFunc           ,+    noDBusInterfaceMethodCallFunc           ,+++-- ** DBusInterfaceSetPropertyFunc+    DBusInterfaceSetPropertyFunc            ,+    DBusInterfaceSetPropertyFuncC           ,+    dBusInterfaceSetPropertyFuncClosure     ,+    dBusInterfaceSetPropertyFuncWrapper     ,+    mkDBusInterfaceSetPropertyFunc          ,+    noDBusInterfaceSetPropertyFunc          ,+++-- ** DBusMessageFilterFunction+    DBusMessageFilterFunction               ,+    DBusMessageFilterFunctionC              ,+    dBusMessageFilterFunctionClosure        ,+    dBusMessageFilterFunctionWrapper        ,+    mkDBusMessageFilterFunction             ,+    noDBusMessageFilterFunction             ,+++-- ** DBusProxyTypeFunc+    DBusProxyTypeFunc                       ,+    DBusProxyTypeFuncC                      ,+    dBusProxyTypeFuncClosure                ,+    dBusProxyTypeFuncWrapper                ,+    mkDBusProxyTypeFunc                     ,+    noDBusProxyTypeFunc                     ,+++-- ** DBusSignalCallback+    DBusSignalCallback                      ,+    DBusSignalCallbackC                     ,+    dBusSignalCallbackClosure               ,+    dBusSignalCallbackWrapper               ,+    mkDBusSignalCallback                    ,+    noDBusSignalCallback                    ,+++-- ** DBusSubtreeDispatchFunc+    DBusSubtreeDispatchFunc                 ,+    DBusSubtreeDispatchFuncC                ,+    dBusSubtreeDispatchFuncClosure          ,+    dBusSubtreeDispatchFuncWrapper          ,+    mkDBusSubtreeDispatchFunc               ,+    noDBusSubtreeDispatchFunc               ,+++-- ** DBusSubtreeIntrospectFunc+    DBusSubtreeIntrospectFunc               ,+    DBusSubtreeIntrospectFuncC              ,+    dBusSubtreeIntrospectFuncClosure        ,+    dBusSubtreeIntrospectFuncWrapper        ,+    mkDBusSubtreeIntrospectFunc             ,+    noDBusSubtreeIntrospectFunc             ,+++-- ** DesktopAppLaunchCallback+    DesktopAppLaunchCallback                ,+    DesktopAppLaunchCallbackC               ,+    desktopAppLaunchCallbackClosure         ,+    desktopAppLaunchCallbackWrapper         ,+    mkDesktopAppLaunchCallback              ,+    noDesktopAppLaunchCallback              ,+++-- ** FileMeasureProgressCallback+    FileMeasureProgressCallback             ,+    FileMeasureProgressCallbackC            ,+    fileMeasureProgressCallbackClosure      ,+    fileMeasureProgressCallbackWrapper      ,+    mkFileMeasureProgressCallback           ,+    noFileMeasureProgressCallback           ,+++-- ** FileProgressCallback+    FileProgressCallback                    ,+    FileProgressCallbackC                   ,+    fileProgressCallbackClosure             ,+    fileProgressCallbackWrapper             ,+    mkFileProgressCallback                  ,+    noFileProgressCallback                  ,+++-- ** FileReadMoreCallback+    FileReadMoreCallback                    ,+    FileReadMoreCallbackC                   ,+    fileReadMoreCallbackClosure             ,+    fileReadMoreCallbackWrapper             ,+    mkFileReadMoreCallback                  ,+    noFileReadMoreCallback                  ,+++-- ** IOSchedulerJobFunc+    IOSchedulerJobFunc                      ,+    IOSchedulerJobFuncC                     ,+    iOSchedulerJobFuncClosure               ,+    iOSchedulerJobFuncWrapper               ,+    mkIOSchedulerJobFunc                    ,+    noIOSchedulerJobFunc                    ,+++-- ** PollableSourceFunc+    PollableSourceFunc                      ,+    PollableSourceFuncC                     ,+    mkPollableSourceFunc                    ,+    noPollableSourceFunc                    ,+    pollableSourceFuncClosure               ,+    pollableSourceFuncWrapper               ,+++-- ** SettingsBindGetMapping+    SettingsBindGetMapping                  ,+    SettingsBindGetMappingC                 ,+    mkSettingsBindGetMapping                ,+    noSettingsBindGetMapping                ,+    settingsBindGetMappingClosure           ,+    settingsBindGetMappingWrapper           ,+++-- ** SettingsBindSetMapping+    SettingsBindSetMapping                  ,+    SettingsBindSetMappingC                 ,+    mkSettingsBindSetMapping                ,+    noSettingsBindSetMapping                ,+    settingsBindSetMappingClosure           ,+    settingsBindSetMappingWrapper           ,+++-- ** SettingsGetMapping+    SettingsGetMapping                      ,+    SettingsGetMappingC                     ,+    mkSettingsGetMapping                    ,+    noSettingsGetMapping                    ,+    settingsGetMappingClosure               ,+    settingsGetMappingWrapper               ,+++-- ** SimpleAsyncThreadFunc+    SimpleAsyncThreadFunc                   ,+    SimpleAsyncThreadFuncC                  ,+    mkSimpleAsyncThreadFunc                 ,+    noSimpleAsyncThreadFunc                 ,+    simpleAsyncThreadFuncClosure            ,+    simpleAsyncThreadFuncWrapper            ,+++-- ** SocketSourceFunc+    SocketSourceFunc                        ,+    SocketSourceFuncC                       ,+    mkSocketSourceFunc                      ,+    noSocketSourceFunc                      ,+    socketSourceFuncClosure                 ,+    socketSourceFuncWrapper                 ,+++-- ** TaskThreadFunc+    TaskThreadFunc                          ,+    TaskThreadFuncC                         ,+    mkTaskThreadFunc                        ,+    noTaskThreadFunc                        ,+    taskThreadFuncClosure                   ,+    taskThreadFuncWrapper                   ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types++import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++-- callback TaskThreadFunc+taskThreadFuncClosure :: TaskThreadFunc -> IO Closure+taskThreadFuncClosure cb = newCClosure =<< mkTaskThreadFunc wrapped+    where wrapped = taskThreadFuncWrapper Nothing cb++type TaskThreadFuncC =+    Ptr Task ->+    Ptr GObject.Object ->+    Ptr () ->+    Ptr Cancellable ->+    IO ()++foreign import ccall "wrapper"+    mkTaskThreadFunc :: TaskThreadFuncC -> IO (FunPtr TaskThreadFuncC)++type TaskThreadFunc =+    Task ->+    GObject.Object ->+    Ptr () ->+    Maybe Cancellable ->+    IO ()++noTaskThreadFunc :: Maybe TaskThreadFunc+noTaskThreadFunc = Nothing++taskThreadFuncWrapper ::+    Maybe (Ptr (FunPtr (TaskThreadFuncC))) ->+    TaskThreadFunc ->+    Ptr Task ->+    Ptr GObject.Object ->+    Ptr () ->+    Ptr Cancellable ->+    IO ()+taskThreadFuncWrapper funptrptr _cb task source_object task_data cancellable = do+    task' <- (newObject Task) task+    source_object' <- (newObject GObject.Object) source_object+    maybeCancellable <-+        if cancellable == nullPtr+        then return Nothing+        else do+            cancellable' <- (newObject Cancellable) cancellable+            return $ Just cancellable'+    _cb  task' source_object' task_data maybeCancellable+    maybeReleaseFunPtr funptrptr++-- callback SocketSourceFunc+socketSourceFuncClosure :: SocketSourceFunc -> IO Closure+socketSourceFuncClosure cb = newCClosure =<< mkSocketSourceFunc wrapped+    where wrapped = socketSourceFuncWrapper Nothing cb++type SocketSourceFuncC =+    Ptr Socket ->+    CUInt ->+    Ptr () ->+    IO CInt++foreign import ccall "wrapper"+    mkSocketSourceFunc :: SocketSourceFuncC -> IO (FunPtr SocketSourceFuncC)++type SocketSourceFunc =+    Socket ->+    [GLib.IOCondition] ->+    IO Bool++noSocketSourceFunc :: Maybe SocketSourceFunc+noSocketSourceFunc = Nothing++socketSourceFuncWrapper ::+    Maybe (Ptr (FunPtr (SocketSourceFuncC))) ->+    SocketSourceFunc ->+    Ptr Socket ->+    CUInt ->+    Ptr () ->+    IO CInt+socketSourceFuncWrapper funptrptr _cb socket condition _ = do+    socket' <- (newObject Socket) socket+    let condition' = wordToGFlags condition+    result <- _cb  socket' condition'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'++-- callback SimpleAsyncThreadFunc+simpleAsyncThreadFuncClosure :: SimpleAsyncThreadFunc -> IO Closure+simpleAsyncThreadFuncClosure cb = newCClosure =<< mkSimpleAsyncThreadFunc wrapped+    where wrapped = simpleAsyncThreadFuncWrapper Nothing cb++type SimpleAsyncThreadFuncC =+    Ptr SimpleAsyncResult ->+    Ptr GObject.Object ->+    Ptr Cancellable ->+    IO ()++foreign import ccall "wrapper"+    mkSimpleAsyncThreadFunc :: SimpleAsyncThreadFuncC -> IO (FunPtr SimpleAsyncThreadFuncC)++type SimpleAsyncThreadFunc =+    SimpleAsyncResult ->+    GObject.Object ->+    Maybe Cancellable ->+    IO ()++noSimpleAsyncThreadFunc :: Maybe SimpleAsyncThreadFunc+noSimpleAsyncThreadFunc = Nothing++simpleAsyncThreadFuncWrapper ::+    Maybe (Ptr (FunPtr (SimpleAsyncThreadFuncC))) ->+    SimpleAsyncThreadFunc ->+    Ptr SimpleAsyncResult ->+    Ptr GObject.Object ->+    Ptr Cancellable ->+    IO ()+simpleAsyncThreadFuncWrapper funptrptr _cb res object cancellable = do+    res' <- (newObject SimpleAsyncResult) res+    object' <- (newObject GObject.Object) object+    maybeCancellable <-+        if cancellable == nullPtr+        then return Nothing+        else do+            cancellable' <- (newObject Cancellable) cancellable+            return $ Just cancellable'+    _cb  res' object' maybeCancellable+    maybeReleaseFunPtr funptrptr++-- callback SettingsGetMapping+settingsGetMappingClosure :: SettingsGetMapping -> IO Closure+settingsGetMappingClosure cb = newCClosure =<< mkSettingsGetMapping wrapped+    where wrapped = settingsGetMappingWrapper Nothing cb++type SettingsGetMappingC =+    Ptr GVariant ->+    Ptr (Ptr ()) ->+    Ptr () ->+    IO CInt++foreign import ccall "wrapper"+    mkSettingsGetMapping :: SettingsGetMappingC -> IO (FunPtr SettingsGetMappingC)++type SettingsGetMapping =+    GVariant ->+    IO (Bool,(Ptr ()))++noSettingsGetMapping :: Maybe SettingsGetMapping+noSettingsGetMapping = Nothing++settingsGetMappingWrapper ::+    Maybe (Ptr (FunPtr (SettingsGetMappingC))) ->+    SettingsGetMapping ->+    Ptr GVariant ->+    Ptr (Ptr ()) ->+    Ptr () ->+    IO CInt+settingsGetMappingWrapper funptrptr _cb value result_ _ = do+    value' <- newGVariantFromPtr value+    (result, outresult_) <- _cb  value'+    poke result_ outresult_+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'++-- callback SettingsBindSetMapping+settingsBindSetMappingClosure :: SettingsBindSetMapping -> IO Closure+settingsBindSetMappingClosure cb = newCClosure =<< mkSettingsBindSetMapping wrapped+    where wrapped = settingsBindSetMappingWrapper Nothing cb++type SettingsBindSetMappingC =+    Ptr GValue ->+    Ptr GLib.VariantType ->+    Ptr () ->+    IO (Ptr GVariant)++foreign import ccall "wrapper"+    mkSettingsBindSetMapping :: SettingsBindSetMappingC -> IO (FunPtr SettingsBindSetMappingC)++type SettingsBindSetMapping =+    GValue ->+    GLib.VariantType ->+    IO GVariant++noSettingsBindSetMapping :: Maybe SettingsBindSetMapping+noSettingsBindSetMapping = Nothing++settingsBindSetMappingWrapper ::+    Maybe (Ptr (FunPtr (SettingsBindSetMappingC))) ->+    SettingsBindSetMapping ->+    Ptr GValue ->+    Ptr GLib.VariantType ->+    Ptr () ->+    IO (Ptr GVariant)+settingsBindSetMappingWrapper funptrptr _cb value expected_type _ = do+    value' <- (newBoxed GValue) value+    expected_type' <- (newBoxed GLib.VariantType) expected_type+    result <- _cb  value' expected_type'+    maybeReleaseFunPtr funptrptr+    result' <- refGVariant result+    return result'++-- callback SettingsBindGetMapping+settingsBindGetMappingClosure :: SettingsBindGetMapping -> IO Closure+settingsBindGetMappingClosure cb = newCClosure =<< mkSettingsBindGetMapping wrapped+    where wrapped = settingsBindGetMappingWrapper Nothing cb++type SettingsBindGetMappingC =+    Ptr GValue ->+    Ptr GVariant ->+    Ptr () ->+    IO CInt++foreign import ccall "wrapper"+    mkSettingsBindGetMapping :: SettingsBindGetMappingC -> IO (FunPtr SettingsBindGetMappingC)++type SettingsBindGetMapping =+    GValue ->+    GVariant ->+    IO Bool++noSettingsBindGetMapping :: Maybe SettingsBindGetMapping+noSettingsBindGetMapping = Nothing++settingsBindGetMappingWrapper ::+    Maybe (Ptr (FunPtr (SettingsBindGetMappingC))) ->+    SettingsBindGetMapping ->+    Ptr GValue ->+    Ptr GVariant ->+    Ptr () ->+    IO CInt+settingsBindGetMappingWrapper funptrptr _cb value variant _ = do+    value' <- (newBoxed GValue) value+    variant' <- newGVariantFromPtr variant+    result <- _cb  value' variant'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'++-- callback PollableSourceFunc+pollableSourceFuncClosure :: PollableSourceFunc -> IO Closure+pollableSourceFuncClosure cb = newCClosure =<< mkPollableSourceFunc wrapped+    where wrapped = pollableSourceFuncWrapper Nothing cb++type PollableSourceFuncC =+    Ptr GObject.Object ->+    Ptr () ->+    IO CInt++foreign import ccall "wrapper"+    mkPollableSourceFunc :: PollableSourceFuncC -> IO (FunPtr PollableSourceFuncC)++type PollableSourceFunc =+    GObject.Object ->+    IO Bool++noPollableSourceFunc :: Maybe PollableSourceFunc+noPollableSourceFunc = Nothing++pollableSourceFuncWrapper ::+    Maybe (Ptr (FunPtr (PollableSourceFuncC))) ->+    PollableSourceFunc ->+    Ptr GObject.Object ->+    Ptr () ->+    IO CInt+pollableSourceFuncWrapper funptrptr _cb pollable_stream _ = do+    pollable_stream' <- (newObject GObject.Object) pollable_stream+    result <- _cb  pollable_stream'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'++-- callback IOSchedulerJobFunc+iOSchedulerJobFuncClosure :: IOSchedulerJobFunc -> IO Closure+iOSchedulerJobFuncClosure cb = newCClosure =<< mkIOSchedulerJobFunc wrapped+    where wrapped = iOSchedulerJobFuncWrapper Nothing cb++type IOSchedulerJobFuncC =+    Ptr IOSchedulerJob ->+    Ptr Cancellable ->+    Ptr () ->+    IO CInt++foreign import ccall "wrapper"+    mkIOSchedulerJobFunc :: IOSchedulerJobFuncC -> IO (FunPtr IOSchedulerJobFuncC)++type IOSchedulerJobFunc =+    IOSchedulerJob ->+    Maybe Cancellable ->+    IO Bool++noIOSchedulerJobFunc :: Maybe IOSchedulerJobFunc+noIOSchedulerJobFunc = Nothing++iOSchedulerJobFuncWrapper ::+    Maybe (Ptr (FunPtr (IOSchedulerJobFuncC))) ->+    IOSchedulerJobFunc ->+    Ptr IOSchedulerJob ->+    Ptr Cancellable ->+    Ptr () ->+    IO CInt+iOSchedulerJobFuncWrapper funptrptr _cb job cancellable _ = do+    -- XXX Wrapping a foreign struct/union with no known destructor, leak?+    job' <- (\x -> IOSchedulerJob <$> newForeignPtr_ x) job+    maybeCancellable <-+        if cancellable == nullPtr+        then return Nothing+        else do+            cancellable' <- (newObject Cancellable) cancellable+            return $ Just cancellable'+    result <- _cb  job' maybeCancellable+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'++-- callback FileReadMoreCallback+fileReadMoreCallbackClosure :: FileReadMoreCallback -> IO Closure+fileReadMoreCallbackClosure cb = newCClosure =<< mkFileReadMoreCallback wrapped+    where wrapped = fileReadMoreCallbackWrapper Nothing cb++type FileReadMoreCallbackC =+    CString ->+    Int64 ->+    Ptr () ->+    IO CInt++foreign import ccall "wrapper"+    mkFileReadMoreCallback :: FileReadMoreCallbackC -> IO (FunPtr FileReadMoreCallbackC)++type FileReadMoreCallback =+    T.Text ->+    Int64 ->+    Ptr () ->+    IO Bool++noFileReadMoreCallback :: Maybe FileReadMoreCallback+noFileReadMoreCallback = Nothing++fileReadMoreCallbackWrapper ::+    Maybe (Ptr (FunPtr (FileReadMoreCallbackC))) ->+    FileReadMoreCallback ->+    CString ->+    Int64 ->+    Ptr () ->+    IO CInt+fileReadMoreCallbackWrapper funptrptr _cb file_contents file_size callback_data = do+    file_contents' <- cstringToText file_contents+    result <- _cb  file_contents' file_size callback_data+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'++-- callback FileProgressCallback+fileProgressCallbackClosure :: FileProgressCallback -> IO Closure+fileProgressCallbackClosure cb = newCClosure =<< mkFileProgressCallback wrapped+    where wrapped = fileProgressCallbackWrapper Nothing cb++type FileProgressCallbackC =+    Int64 ->+    Int64 ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkFileProgressCallback :: FileProgressCallbackC -> IO (FunPtr FileProgressCallbackC)++type FileProgressCallback =+    Int64 ->+    Int64 ->+    IO ()++noFileProgressCallback :: Maybe FileProgressCallback+noFileProgressCallback = Nothing++fileProgressCallbackWrapper ::+    Maybe (Ptr (FunPtr (FileProgressCallbackC))) ->+    FileProgressCallback ->+    Int64 ->+    Int64 ->+    Ptr () ->+    IO ()+fileProgressCallbackWrapper funptrptr _cb current_num_bytes total_num_bytes _ = do+    _cb  current_num_bytes total_num_bytes+    maybeReleaseFunPtr funptrptr++-- callback FileMeasureProgressCallback+fileMeasureProgressCallbackClosure :: FileMeasureProgressCallback -> IO Closure+fileMeasureProgressCallbackClosure cb = newCClosure =<< mkFileMeasureProgressCallback wrapped+    where wrapped = fileMeasureProgressCallbackWrapper Nothing cb++type FileMeasureProgressCallbackC =+    CInt ->+    Word64 ->+    Word64 ->+    Word64 ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkFileMeasureProgressCallback :: FileMeasureProgressCallbackC -> IO (FunPtr FileMeasureProgressCallbackC)++type FileMeasureProgressCallback =+    Bool ->+    Word64 ->+    Word64 ->+    Word64 ->+    IO ()++noFileMeasureProgressCallback :: Maybe FileMeasureProgressCallback+noFileMeasureProgressCallback = Nothing++fileMeasureProgressCallbackWrapper ::+    Maybe (Ptr (FunPtr (FileMeasureProgressCallbackC))) ->+    FileMeasureProgressCallback ->+    CInt ->+    Word64 ->+    Word64 ->+    Word64 ->+    Ptr () ->+    IO ()+fileMeasureProgressCallbackWrapper funptrptr _cb reporting current_size num_dirs num_files _ = do+    let reporting' = (/= 0) reporting+    _cb  reporting' current_size num_dirs num_files+    maybeReleaseFunPtr funptrptr++-- callback DesktopAppLaunchCallback+desktopAppLaunchCallbackClosure :: DesktopAppLaunchCallback -> IO Closure+desktopAppLaunchCallbackClosure cb = newCClosure =<< mkDesktopAppLaunchCallback wrapped+    where wrapped = desktopAppLaunchCallbackWrapper Nothing cb++type DesktopAppLaunchCallbackC =+    Ptr DesktopAppInfo ->+    Int32 ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkDesktopAppLaunchCallback :: DesktopAppLaunchCallbackC -> IO (FunPtr DesktopAppLaunchCallbackC)++type DesktopAppLaunchCallback =+    DesktopAppInfo ->+    Int32 ->+    IO ()++noDesktopAppLaunchCallback :: Maybe DesktopAppLaunchCallback+noDesktopAppLaunchCallback = Nothing++desktopAppLaunchCallbackWrapper ::+    Maybe (Ptr (FunPtr (DesktopAppLaunchCallbackC))) ->+    DesktopAppLaunchCallback ->+    Ptr DesktopAppInfo ->+    Int32 ->+    Ptr () ->+    IO ()+desktopAppLaunchCallbackWrapper funptrptr _cb appinfo pid _ = do+    appinfo' <- (newObject DesktopAppInfo) appinfo+    _cb  appinfo' pid+    maybeReleaseFunPtr funptrptr++-- callback DBusSubtreeIntrospectFunc+dBusSubtreeIntrospectFuncClosure :: DBusSubtreeIntrospectFunc -> IO Closure+dBusSubtreeIntrospectFuncClosure cb = newCClosure =<< mkDBusSubtreeIntrospectFunc wrapped+    where wrapped = dBusSubtreeIntrospectFuncWrapper Nothing cb++type DBusSubtreeIntrospectFuncC =+    Ptr DBusConnection ->+    CString ->+    CString ->+    CString ->+    Ptr () ->+    IO (Ptr DBusInterfaceInfo)++foreign import ccall "wrapper"+    mkDBusSubtreeIntrospectFunc :: DBusSubtreeIntrospectFuncC -> IO (FunPtr DBusSubtreeIntrospectFuncC)++type DBusSubtreeIntrospectFunc =+    DBusConnection ->+    T.Text ->+    T.Text ->+    T.Text ->+    IO DBusInterfaceInfo++noDBusSubtreeIntrospectFunc :: Maybe DBusSubtreeIntrospectFunc+noDBusSubtreeIntrospectFunc = Nothing++dBusSubtreeIntrospectFuncWrapper ::+    Maybe (Ptr (FunPtr (DBusSubtreeIntrospectFuncC))) ->+    DBusSubtreeIntrospectFunc ->+    Ptr DBusConnection ->+    CString ->+    CString ->+    CString ->+    Ptr () ->+    IO (Ptr DBusInterfaceInfo)+dBusSubtreeIntrospectFuncWrapper funptrptr _cb connection sender object_path node _ = do+    connection' <- (newObject DBusConnection) connection+    sender' <- cstringToText sender+    object_path' <- cstringToText object_path+    node' <- cstringToText node+    result <- _cb  connection' sender' object_path' node'+    maybeReleaseFunPtr funptrptr+    result' <- copyBoxed result+    return result'++-- callback DBusSubtreeDispatchFunc+dBusSubtreeDispatchFuncClosure :: DBusSubtreeDispatchFunc -> IO Closure+dBusSubtreeDispatchFuncClosure cb = newCClosure =<< mkDBusSubtreeDispatchFunc wrapped+    where wrapped = dBusSubtreeDispatchFuncWrapper Nothing cb++type DBusSubtreeDispatchFuncC =+    Ptr DBusConnection ->+    CString ->+    CString ->+    CString ->+    CString ->+    Ptr () ->+    Ptr () ->+    IO (Ptr DBusInterfaceVTable)++foreign import ccall "wrapper"+    mkDBusSubtreeDispatchFunc :: DBusSubtreeDispatchFuncC -> IO (FunPtr DBusSubtreeDispatchFuncC)++type DBusSubtreeDispatchFunc =+    DBusConnection ->+    T.Text ->+    T.Text ->+    T.Text ->+    T.Text ->+    Ptr () ->+    IO DBusInterfaceVTable++noDBusSubtreeDispatchFunc :: Maybe DBusSubtreeDispatchFunc+noDBusSubtreeDispatchFunc = Nothing++dBusSubtreeDispatchFuncWrapper ::+    Maybe (Ptr (FunPtr (DBusSubtreeDispatchFuncC))) ->+    DBusSubtreeDispatchFunc ->+    Ptr DBusConnection ->+    CString ->+    CString ->+    CString ->+    CString ->+    Ptr () ->+    Ptr () ->+    IO (Ptr DBusInterfaceVTable)+dBusSubtreeDispatchFuncWrapper funptrptr _cb connection sender object_path interface_name node out_user_data _ = do+    connection' <- (newObject DBusConnection) connection+    sender' <- cstringToText sender+    object_path' <- cstringToText object_path+    interface_name' <- cstringToText interface_name+    node' <- cstringToText node+    result <- _cb  connection' sender' object_path' interface_name' node' out_user_data+    maybeReleaseFunPtr funptrptr+    let result' = unsafeManagedPtrGetPtr result+    return result'++-- callback DBusSignalCallback+dBusSignalCallbackClosure :: DBusSignalCallback -> IO Closure+dBusSignalCallbackClosure cb = newCClosure =<< mkDBusSignalCallback wrapped+    where wrapped = dBusSignalCallbackWrapper Nothing cb++type DBusSignalCallbackC =+    Ptr DBusConnection ->+    CString ->+    CString ->+    CString ->+    CString ->+    Ptr GVariant ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkDBusSignalCallback :: DBusSignalCallbackC -> IO (FunPtr DBusSignalCallbackC)++type DBusSignalCallback =+    DBusConnection ->+    T.Text ->+    T.Text ->+    T.Text ->+    T.Text ->+    GVariant ->+    IO ()++noDBusSignalCallback :: Maybe DBusSignalCallback+noDBusSignalCallback = Nothing++dBusSignalCallbackWrapper ::+    Maybe (Ptr (FunPtr (DBusSignalCallbackC))) ->+    DBusSignalCallback ->+    Ptr DBusConnection ->+    CString ->+    CString ->+    CString ->+    CString ->+    Ptr GVariant ->+    Ptr () ->+    IO ()+dBusSignalCallbackWrapper funptrptr _cb connection sender_name object_path interface_name signal_name parameters _ = do+    connection' <- (newObject DBusConnection) connection+    sender_name' <- cstringToText sender_name+    object_path' <- cstringToText object_path+    interface_name' <- cstringToText interface_name+    signal_name' <- cstringToText signal_name+    parameters' <- newGVariantFromPtr parameters+    _cb  connection' sender_name' object_path' interface_name' signal_name' parameters'+    maybeReleaseFunPtr funptrptr++-- callback DBusProxyTypeFunc+dBusProxyTypeFuncClosure :: DBusProxyTypeFunc -> IO Closure+dBusProxyTypeFuncClosure cb = newCClosure =<< mkDBusProxyTypeFunc wrapped+    where wrapped = dBusProxyTypeFuncWrapper Nothing cb++type DBusProxyTypeFuncC =+    Ptr DBusObjectManagerClient ->+    CString ->+    CString ->+    Ptr () ->+    IO CGType++foreign import ccall "wrapper"+    mkDBusProxyTypeFunc :: DBusProxyTypeFuncC -> IO (FunPtr DBusProxyTypeFuncC)++type DBusProxyTypeFunc =+    DBusObjectManagerClient ->+    T.Text ->+    Maybe T.Text ->+    IO GType++noDBusProxyTypeFunc :: Maybe DBusProxyTypeFunc+noDBusProxyTypeFunc = Nothing++dBusProxyTypeFuncWrapper ::+    Maybe (Ptr (FunPtr (DBusProxyTypeFuncC))) ->+    DBusProxyTypeFunc ->+    Ptr DBusObjectManagerClient ->+    CString ->+    CString ->+    Ptr () ->+    IO CGType+dBusProxyTypeFuncWrapper funptrptr _cb manager object_path interface_name _ = do+    manager' <- (newObject DBusObjectManagerClient) manager+    object_path' <- cstringToText object_path+    maybeInterface_name <-+        if interface_name == nullPtr+        then return Nothing+        else do+            interface_name' <- cstringToText interface_name+            return $ Just interface_name'+    result <- _cb  manager' object_path' maybeInterface_name+    maybeReleaseFunPtr funptrptr+    let result' = gtypeToCGType result+    return result'++-- callback DBusMessageFilterFunction+dBusMessageFilterFunctionClosure :: DBusMessageFilterFunction -> IO Closure+dBusMessageFilterFunctionClosure cb = newCClosure =<< mkDBusMessageFilterFunction wrapped+    where wrapped = dBusMessageFilterFunctionWrapper Nothing cb++type DBusMessageFilterFunctionC =+    Ptr DBusConnection ->+    Ptr DBusMessage ->+    CInt ->+    Ptr () ->+    IO (Ptr DBusMessage)++foreign import ccall "wrapper"+    mkDBusMessageFilterFunction :: DBusMessageFilterFunctionC -> IO (FunPtr DBusMessageFilterFunctionC)++type DBusMessageFilterFunction =+    DBusConnection ->+    DBusMessage ->+    Bool ->+    IO DBusMessage++noDBusMessageFilterFunction :: Maybe DBusMessageFilterFunction+noDBusMessageFilterFunction = Nothing++dBusMessageFilterFunctionWrapper ::+    Maybe (Ptr (FunPtr (DBusMessageFilterFunctionC))) ->+    DBusMessageFilterFunction ->+    Ptr DBusConnection ->+    Ptr DBusMessage ->+    CInt ->+    Ptr () ->+    IO (Ptr DBusMessage)+dBusMessageFilterFunctionWrapper funptrptr _cb connection message incoming _ = do+    connection' <- (newObject DBusConnection) connection+    message' <- (wrapObject DBusMessage) message+    let incoming' = (/= 0) incoming+    result <- _cb  connection' message' incoming'+    maybeReleaseFunPtr funptrptr+    result' <- refObject result+    return result'++-- callback DBusInterfaceSetPropertyFunc+dBusInterfaceSetPropertyFuncClosure :: DBusInterfaceSetPropertyFunc -> IO Closure+dBusInterfaceSetPropertyFuncClosure cb = newCClosure =<< mkDBusInterfaceSetPropertyFunc wrapped+    where wrapped = dBusInterfaceSetPropertyFuncWrapper Nothing cb++type DBusInterfaceSetPropertyFuncC =+    Ptr DBusConnection ->+    CString ->+    CString ->+    CString ->+    CString ->+    Ptr GVariant ->+    Ptr GError ->+    Ptr () ->+    IO CInt++foreign import ccall "wrapper"+    mkDBusInterfaceSetPropertyFunc :: DBusInterfaceSetPropertyFuncC -> IO (FunPtr DBusInterfaceSetPropertyFuncC)++type DBusInterfaceSetPropertyFunc =+    DBusConnection ->+    T.Text ->+    T.Text ->+    T.Text ->+    T.Text ->+    GVariant ->+    GError ->+    IO Bool++noDBusInterfaceSetPropertyFunc :: Maybe DBusInterfaceSetPropertyFunc+noDBusInterfaceSetPropertyFunc = Nothing++dBusInterfaceSetPropertyFuncWrapper ::+    Maybe (Ptr (FunPtr (DBusInterfaceSetPropertyFuncC))) ->+    DBusInterfaceSetPropertyFunc ->+    Ptr DBusConnection ->+    CString ->+    CString ->+    CString ->+    CString ->+    Ptr GVariant ->+    Ptr GError ->+    Ptr () ->+    IO CInt+dBusInterfaceSetPropertyFuncWrapper funptrptr _cb connection sender object_path interface_name property_name value error_ _ = do+    connection' <- (newObject DBusConnection) connection+    sender' <- cstringToText sender+    object_path' <- cstringToText object_path+    interface_name' <- cstringToText interface_name+    property_name' <- cstringToText property_name+    value' <- newGVariantFromPtr value+    error_' <- (newBoxed GError) error_+    result <- _cb  connection' sender' object_path' interface_name' property_name' value' error_'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'++-- callback DBusInterfaceMethodCallFunc+dBusInterfaceMethodCallFuncClosure :: DBusInterfaceMethodCallFunc -> IO Closure+dBusInterfaceMethodCallFuncClosure cb = newCClosure =<< mkDBusInterfaceMethodCallFunc wrapped+    where wrapped = dBusInterfaceMethodCallFuncWrapper Nothing cb++type DBusInterfaceMethodCallFuncC =+    Ptr DBusConnection ->+    CString ->+    CString ->+    CString ->+    CString ->+    Ptr GVariant ->+    Ptr DBusMethodInvocation ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkDBusInterfaceMethodCallFunc :: DBusInterfaceMethodCallFuncC -> IO (FunPtr DBusInterfaceMethodCallFuncC)++type DBusInterfaceMethodCallFunc =+    DBusConnection ->+    T.Text ->+    T.Text ->+    T.Text ->+    T.Text ->+    GVariant ->+    DBusMethodInvocation ->+    IO ()++noDBusInterfaceMethodCallFunc :: Maybe DBusInterfaceMethodCallFunc+noDBusInterfaceMethodCallFunc = Nothing++dBusInterfaceMethodCallFuncWrapper ::+    Maybe (Ptr (FunPtr (DBusInterfaceMethodCallFuncC))) ->+    DBusInterfaceMethodCallFunc ->+    Ptr DBusConnection ->+    CString ->+    CString ->+    CString ->+    CString ->+    Ptr GVariant ->+    Ptr DBusMethodInvocation ->+    Ptr () ->+    IO ()+dBusInterfaceMethodCallFuncWrapper funptrptr _cb connection sender object_path interface_name method_name parameters invocation _ = do+    connection' <- (newObject DBusConnection) connection+    sender' <- cstringToText sender+    object_path' <- cstringToText object_path+    interface_name' <- cstringToText interface_name+    method_name' <- cstringToText method_name+    parameters' <- newGVariantFromPtr parameters+    invocation' <- (wrapObject DBusMethodInvocation) invocation+    _cb  connection' sender' object_path' interface_name' method_name' parameters' invocation'+    maybeReleaseFunPtr funptrptr++-- callback DBusInterfaceGetPropertyFunc+dBusInterfaceGetPropertyFuncClosure :: DBusInterfaceGetPropertyFunc -> IO Closure+dBusInterfaceGetPropertyFuncClosure cb = newCClosure =<< mkDBusInterfaceGetPropertyFunc wrapped+    where wrapped = dBusInterfaceGetPropertyFuncWrapper Nothing cb++type DBusInterfaceGetPropertyFuncC =+    Ptr DBusConnection ->+    CString ->+    CString ->+    CString ->+    CString ->+    Ptr GError ->+    Ptr () ->+    IO (Ptr GVariant)++foreign import ccall "wrapper"+    mkDBusInterfaceGetPropertyFunc :: DBusInterfaceGetPropertyFuncC -> IO (FunPtr DBusInterfaceGetPropertyFuncC)++type DBusInterfaceGetPropertyFunc =+    DBusConnection ->+    T.Text ->+    T.Text ->+    T.Text ->+    T.Text ->+    GError ->+    IO GVariant++noDBusInterfaceGetPropertyFunc :: Maybe DBusInterfaceGetPropertyFunc+noDBusInterfaceGetPropertyFunc = Nothing++dBusInterfaceGetPropertyFuncWrapper ::+    Maybe (Ptr (FunPtr (DBusInterfaceGetPropertyFuncC))) ->+    DBusInterfaceGetPropertyFunc ->+    Ptr DBusConnection ->+    CString ->+    CString ->+    CString ->+    CString ->+    Ptr GError ->+    Ptr () ->+    IO (Ptr GVariant)+dBusInterfaceGetPropertyFuncWrapper funptrptr _cb connection sender object_path interface_name property_name error_ _ = do+    connection' <- (newObject DBusConnection) connection+    sender' <- cstringToText sender+    object_path' <- cstringToText object_path+    interface_name' <- cstringToText interface_name+    property_name' <- cstringToText property_name+    error_' <- (newBoxed GError) error_+    result <- _cb  connection' sender' object_path' interface_name' property_name' error_'+    maybeReleaseFunPtr funptrptr+    result' <- refGVariant result+    return result'++-- callback CancellableSourceFunc+cancellableSourceFuncClosure :: CancellableSourceFunc -> IO Closure+cancellableSourceFuncClosure cb = newCClosure =<< mkCancellableSourceFunc wrapped+    where wrapped = cancellableSourceFuncWrapper Nothing cb++type CancellableSourceFuncC =+    Ptr Cancellable ->+    Ptr () ->+    IO CInt++foreign import ccall "wrapper"+    mkCancellableSourceFunc :: CancellableSourceFuncC -> IO (FunPtr CancellableSourceFuncC)++type CancellableSourceFunc =+    Maybe Cancellable ->+    IO Bool++noCancellableSourceFunc :: Maybe CancellableSourceFunc+noCancellableSourceFunc = Nothing++cancellableSourceFuncWrapper ::+    Maybe (Ptr (FunPtr (CancellableSourceFuncC))) ->+    CancellableSourceFunc ->+    Ptr Cancellable ->+    Ptr () ->+    IO CInt+cancellableSourceFuncWrapper funptrptr _cb cancellable _ = do+    maybeCancellable <-+        if cancellable == nullPtr+        then return Nothing+        else do+            cancellable' <- (newObject Cancellable) cancellable+            return $ Just cancellable'+    result <- _cb  maybeCancellable+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'++-- callback BusNameVanishedCallback+busNameVanishedCallbackClosure :: BusNameVanishedCallback -> IO Closure+busNameVanishedCallbackClosure cb = newCClosure =<< mkBusNameVanishedCallback wrapped+    where wrapped = busNameVanishedCallbackWrapper Nothing cb++type BusNameVanishedCallbackC =+    Ptr DBusConnection ->+    CString ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkBusNameVanishedCallback :: BusNameVanishedCallbackC -> IO (FunPtr BusNameVanishedCallbackC)++type BusNameVanishedCallback =+    DBusConnection ->+    T.Text ->+    IO ()++noBusNameVanishedCallback :: Maybe BusNameVanishedCallback+noBusNameVanishedCallback = Nothing++busNameVanishedCallbackWrapper ::+    Maybe (Ptr (FunPtr (BusNameVanishedCallbackC))) ->+    BusNameVanishedCallback ->+    Ptr DBusConnection ->+    CString ->+    Ptr () ->+    IO ()+busNameVanishedCallbackWrapper funptrptr _cb connection name _ = do+    connection' <- (newObject DBusConnection) connection+    name' <- cstringToText name+    _cb  connection' name'+    maybeReleaseFunPtr funptrptr++-- callback BusNameLostCallback+busNameLostCallbackClosure :: BusNameLostCallback -> IO Closure+busNameLostCallbackClosure cb = newCClosure =<< mkBusNameLostCallback wrapped+    where wrapped = busNameLostCallbackWrapper Nothing cb++type BusNameLostCallbackC =+    Ptr DBusConnection ->+    CString ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkBusNameLostCallback :: BusNameLostCallbackC -> IO (FunPtr BusNameLostCallbackC)++type BusNameLostCallback =+    DBusConnection ->+    T.Text ->+    IO ()++noBusNameLostCallback :: Maybe BusNameLostCallback+noBusNameLostCallback = Nothing++busNameLostCallbackWrapper ::+    Maybe (Ptr (FunPtr (BusNameLostCallbackC))) ->+    BusNameLostCallback ->+    Ptr DBusConnection ->+    CString ->+    Ptr () ->+    IO ()+busNameLostCallbackWrapper funptrptr _cb connection name _ = do+    connection' <- (newObject DBusConnection) connection+    name' <- cstringToText name+    _cb  connection' name'+    maybeReleaseFunPtr funptrptr++-- callback BusNameAppearedCallback+busNameAppearedCallbackClosure :: BusNameAppearedCallback -> IO Closure+busNameAppearedCallbackClosure cb = newCClosure =<< mkBusNameAppearedCallback wrapped+    where wrapped = busNameAppearedCallbackWrapper Nothing cb++type BusNameAppearedCallbackC =+    Ptr DBusConnection ->+    CString ->+    CString ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkBusNameAppearedCallback :: BusNameAppearedCallbackC -> IO (FunPtr BusNameAppearedCallbackC)++type BusNameAppearedCallback =+    DBusConnection ->+    T.Text ->+    T.Text ->+    IO ()++noBusNameAppearedCallback :: Maybe BusNameAppearedCallback+noBusNameAppearedCallback = Nothing++busNameAppearedCallbackWrapper ::+    Maybe (Ptr (FunPtr (BusNameAppearedCallbackC))) ->+    BusNameAppearedCallback ->+    Ptr DBusConnection ->+    CString ->+    CString ->+    Ptr () ->+    IO ()+busNameAppearedCallbackWrapper funptrptr _cb connection name name_owner _ = do+    connection' <- (newObject DBusConnection) connection+    name' <- cstringToText name+    name_owner' <- cstringToText name_owner+    _cb  connection' name' name_owner'+    maybeReleaseFunPtr funptrptr++-- callback BusNameAcquiredCallback+busNameAcquiredCallbackClosure :: BusNameAcquiredCallback -> IO Closure+busNameAcquiredCallbackClosure cb = newCClosure =<< mkBusNameAcquiredCallback wrapped+    where wrapped = busNameAcquiredCallbackWrapper Nothing cb++type BusNameAcquiredCallbackC =+    Ptr DBusConnection ->+    CString ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkBusNameAcquiredCallback :: BusNameAcquiredCallbackC -> IO (FunPtr BusNameAcquiredCallbackC)++type BusNameAcquiredCallback =+    DBusConnection ->+    T.Text ->+    IO ()++noBusNameAcquiredCallback :: Maybe BusNameAcquiredCallback+noBusNameAcquiredCallback = Nothing++busNameAcquiredCallbackWrapper ::+    Maybe (Ptr (FunPtr (BusNameAcquiredCallbackC))) ->+    BusNameAcquiredCallback ->+    Ptr DBusConnection ->+    CString ->+    Ptr () ->+    IO ()+busNameAcquiredCallbackWrapper funptrptr _cb connection name _ = do+    connection' <- (newObject DBusConnection) connection+    name' <- cstringToText name+    _cb  connection' name'+    maybeReleaseFunPtr funptrptr++-- callback BusAcquiredCallback+busAcquiredCallbackClosure :: BusAcquiredCallback -> IO Closure+busAcquiredCallbackClosure cb = newCClosure =<< mkBusAcquiredCallback wrapped+    where wrapped = busAcquiredCallbackWrapper Nothing cb++type BusAcquiredCallbackC =+    Ptr DBusConnection ->+    CString ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkBusAcquiredCallback :: BusAcquiredCallbackC -> IO (FunPtr BusAcquiredCallbackC)++type BusAcquiredCallback =+    DBusConnection ->+    T.Text ->+    IO ()++noBusAcquiredCallback :: Maybe BusAcquiredCallback+noBusAcquiredCallback = Nothing++busAcquiredCallbackWrapper ::+    Maybe (Ptr (FunPtr (BusAcquiredCallbackC))) ->+    BusAcquiredCallback ->+    Ptr DBusConnection ->+    CString ->+    Ptr () ->+    IO ()+busAcquiredCallbackWrapper funptrptr _cb connection name _ = do+    connection' <- (newObject DBusConnection) connection+    name' <- cstringToText name+    _cb  connection' name'+    maybeReleaseFunPtr funptrptr++-- callback AsyncReadyCallback+asyncReadyCallbackClosure :: AsyncReadyCallback -> IO Closure+asyncReadyCallbackClosure cb = newCClosure =<< mkAsyncReadyCallback wrapped+    where wrapped = asyncReadyCallbackWrapper Nothing cb++type AsyncReadyCallbackC =+    Ptr GObject.Object ->+    Ptr AsyncResult ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkAsyncReadyCallback :: AsyncReadyCallbackC -> IO (FunPtr AsyncReadyCallbackC)++type AsyncReadyCallback =+    GObject.Object ->+    AsyncResult ->+    IO ()++noAsyncReadyCallback :: Maybe AsyncReadyCallback+noAsyncReadyCallback = Nothing++asyncReadyCallbackWrapper ::+    Maybe (Ptr (FunPtr (AsyncReadyCallbackC))) ->+    AsyncReadyCallback ->+    Ptr GObject.Object ->+    Ptr AsyncResult ->+    Ptr () ->+    IO ()+asyncReadyCallbackWrapper funptrptr _cb source_object res _ = do+    source_object' <- (newObject GObject.Object) source_object+    res' <- (newObject AsyncResult) res+    _cb  source_object' res'+    maybeReleaseFunPtr funptrptr++-- callback ActionEntryChangeStateFieldCallback+actionEntryChangeStateFieldCallbackClosure :: ActionEntryChangeStateFieldCallback -> IO Closure+actionEntryChangeStateFieldCallbackClosure cb = newCClosure =<< mkActionEntryChangeStateFieldCallback wrapped+    where wrapped = actionEntryChangeStateFieldCallbackWrapper Nothing cb++type ActionEntryChangeStateFieldCallbackC =+    Ptr SimpleAction ->+    Ptr GVariant ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkActionEntryChangeStateFieldCallback :: ActionEntryChangeStateFieldCallbackC -> IO (FunPtr ActionEntryChangeStateFieldCallbackC)++type ActionEntryChangeStateFieldCallback =+    SimpleAction ->+    GVariant ->+    IO ()++noActionEntryChangeStateFieldCallback :: Maybe ActionEntryChangeStateFieldCallback+noActionEntryChangeStateFieldCallback = Nothing++actionEntryChangeStateFieldCallbackWrapper ::+    Maybe (Ptr (FunPtr (ActionEntryChangeStateFieldCallbackC))) ->+    ActionEntryChangeStateFieldCallback ->+    Ptr SimpleAction ->+    Ptr GVariant ->+    Ptr () ->+    IO ()+actionEntryChangeStateFieldCallbackWrapper funptrptr _cb action value _ = do+    action' <- (newObject SimpleAction) action+    value' <- newGVariantFromPtr value+    _cb  action' value'+    maybeReleaseFunPtr funptrptr++-- callback ActionEntryActivateFieldCallback+actionEntryActivateFieldCallbackClosure :: ActionEntryActivateFieldCallback -> IO Closure+actionEntryActivateFieldCallbackClosure cb = newCClosure =<< mkActionEntryActivateFieldCallback wrapped+    where wrapped = actionEntryActivateFieldCallbackWrapper Nothing cb++type ActionEntryActivateFieldCallbackC =+    Ptr SimpleAction ->+    Ptr GVariant ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkActionEntryActivateFieldCallback :: ActionEntryActivateFieldCallbackC -> IO (FunPtr ActionEntryActivateFieldCallbackC)++type ActionEntryActivateFieldCallback =+    SimpleAction ->+    GVariant ->+    IO ()++noActionEntryActivateFieldCallback :: Maybe ActionEntryActivateFieldCallback+noActionEntryActivateFieldCallback = Nothing++actionEntryActivateFieldCallbackWrapper ::+    Maybe (Ptr (FunPtr (ActionEntryActivateFieldCallbackC))) ->+    ActionEntryActivateFieldCallback ->+    Ptr SimpleAction ->+    Ptr GVariant ->+    Ptr () ->+    IO ()+actionEntryActivateFieldCallbackWrapper funptrptr _cb action parameter _ = do+    action' <- (newObject SimpleAction) action+    parameter' <- newGVariantFromPtr parameter+    _cb  action' parameter'+    maybeReleaseFunPtr funptrptr++
+ GI/Gio/Constants.hs view
@@ -0,0 +1,432 @@+{-# LANGUAGE PatternSynonyms, ScopedTypeVariables, ViewPatterns #-}++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Constants+    ( +    pattern VOLUME_MONITOR_EXTENSION_POINT_NAME,+    pattern VOLUME_IDENTIFIER_KIND_UUID     ,+    pattern VOLUME_IDENTIFIER_KIND_UNIX_DEVICE,+    pattern VOLUME_IDENTIFIER_KIND_NFS_MOUNT,+    pattern VOLUME_IDENTIFIER_KIND_LABEL    ,+    pattern VOLUME_IDENTIFIER_KIND_HAL_UDI  ,+    pattern VOLUME_IDENTIFIER_KIND_CLASS    ,+    pattern VFS_EXTENSION_POINT_NAME        ,+    pattern TLS_DATABASE_PURPOSE_AUTHENTICATE_SERVER,+    pattern TLS_DATABASE_PURPOSE_AUTHENTICATE_CLIENT,+    pattern TLS_BACKEND_EXTENSION_POINT_NAME,+    pattern PROXY_RESOLVER_EXTENSION_POINT_NAME,+    pattern PROXY_EXTENSION_POINT_NAME      ,+    pattern NETWORK_MONITOR_EXTENSION_POINT_NAME,+    pattern NATIVE_VOLUME_MONITOR_EXTENSION_POINT_NAME,+    pattern MENU_LINK_SUBMENU               ,+    pattern MENU_LINK_SECTION               ,+    pattern MENU_ATTRIBUTE_TARGET           ,+    pattern MENU_ATTRIBUTE_LABEL            ,+    pattern MENU_ATTRIBUTE_ICON             ,+    pattern MENU_ATTRIBUTE_ACTION_NAMESPACE ,+    pattern MENU_ATTRIBUTE_ACTION           ,+    pattern FILE_ATTRIBUTE_UNIX_UID         ,+    pattern FILE_ATTRIBUTE_UNIX_RDEV        ,+    pattern FILE_ATTRIBUTE_UNIX_NLINK       ,+    pattern FILE_ATTRIBUTE_UNIX_MODE        ,+    pattern FILE_ATTRIBUTE_UNIX_IS_MOUNTPOINT,+    pattern FILE_ATTRIBUTE_UNIX_INODE       ,+    pattern FILE_ATTRIBUTE_UNIX_GID         ,+    pattern FILE_ATTRIBUTE_UNIX_DEVICE      ,+    pattern FILE_ATTRIBUTE_UNIX_BLOCK_SIZE  ,+    pattern FILE_ATTRIBUTE_UNIX_BLOCKS      ,+    pattern FILE_ATTRIBUTE_TRASH_ORIG_PATH  ,+    pattern FILE_ATTRIBUTE_TRASH_ITEM_COUNT ,+    pattern FILE_ATTRIBUTE_TRASH_DELETION_DATE,+    pattern FILE_ATTRIBUTE_TIME_MODIFIED_USEC,+    pattern FILE_ATTRIBUTE_TIME_MODIFIED    ,+    pattern FILE_ATTRIBUTE_TIME_CREATED_USEC,+    pattern FILE_ATTRIBUTE_TIME_CREATED     ,+    pattern FILE_ATTRIBUTE_TIME_CHANGED_USEC,+    pattern FILE_ATTRIBUTE_TIME_CHANGED     ,+    pattern FILE_ATTRIBUTE_TIME_ACCESS_USEC ,+    pattern FILE_ATTRIBUTE_TIME_ACCESS      ,+    pattern FILE_ATTRIBUTE_THUMBNAIL_PATH   ,+    pattern FILE_ATTRIBUTE_THUMBNAIL_IS_VALID,+    pattern FILE_ATTRIBUTE_THUMBNAILING_FAILED,+    pattern FILE_ATTRIBUTE_STANDARD_TYPE    ,+    pattern FILE_ATTRIBUTE_STANDARD_TARGET_URI,+    pattern FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET,+    pattern FILE_ATTRIBUTE_STANDARD_SYMBOLIC_ICON,+    pattern FILE_ATTRIBUTE_STANDARD_SORT_ORDER,+    pattern FILE_ATTRIBUTE_STANDARD_SIZE    ,+    pattern FILE_ATTRIBUTE_STANDARD_NAME    ,+    pattern FILE_ATTRIBUTE_STANDARD_IS_VOLATILE,+    pattern FILE_ATTRIBUTE_STANDARD_IS_VIRTUAL,+    pattern FILE_ATTRIBUTE_STANDARD_IS_SYMLINK,+    pattern FILE_ATTRIBUTE_STANDARD_IS_HIDDEN,+    pattern FILE_ATTRIBUTE_STANDARD_IS_BACKUP,+    pattern FILE_ATTRIBUTE_STANDARD_ICON    ,+    pattern FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE,+    pattern FILE_ATTRIBUTE_STANDARD_EDIT_NAME,+    pattern FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME,+    pattern FILE_ATTRIBUTE_STANDARD_DESCRIPTION,+    pattern FILE_ATTRIBUTE_STANDARD_COPY_NAME,+    pattern FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,+    pattern FILE_ATTRIBUTE_STANDARD_ALLOCATED_SIZE,+    pattern FILE_ATTRIBUTE_SELINUX_CONTEXT  ,+    pattern FILE_ATTRIBUTE_PREVIEW_ICON     ,+    pattern FILE_ATTRIBUTE_OWNER_USER_REAL  ,+    pattern FILE_ATTRIBUTE_OWNER_USER       ,+    pattern FILE_ATTRIBUTE_OWNER_GROUP      ,+    pattern FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE_FILE,+    pattern FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE,+    pattern FILE_ATTRIBUTE_MOUNTABLE_START_STOP_TYPE,+    pattern FILE_ATTRIBUTE_MOUNTABLE_IS_MEDIA_CHECK_AUTOMATIC,+    pattern FILE_ATTRIBUTE_MOUNTABLE_HAL_UDI,+    pattern FILE_ATTRIBUTE_MOUNTABLE_CAN_UNMOUNT,+    pattern FILE_ATTRIBUTE_MOUNTABLE_CAN_STOP,+    pattern FILE_ATTRIBUTE_MOUNTABLE_CAN_START_DEGRADED,+    pattern FILE_ATTRIBUTE_MOUNTABLE_CAN_START,+    pattern FILE_ATTRIBUTE_MOUNTABLE_CAN_POLL,+    pattern FILE_ATTRIBUTE_MOUNTABLE_CAN_MOUNT,+    pattern FILE_ATTRIBUTE_MOUNTABLE_CAN_EJECT,+    pattern FILE_ATTRIBUTE_ID_FILESYSTEM    ,+    pattern FILE_ATTRIBUTE_ID_FILE          ,+    pattern FILE_ATTRIBUTE_GVFS_BACKEND     ,+    pattern FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW,+    pattern FILE_ATTRIBUTE_FILESYSTEM_USED  ,+    pattern FILE_ATTRIBUTE_FILESYSTEM_TYPE  ,+    pattern FILE_ATTRIBUTE_FILESYSTEM_SIZE  ,+    pattern FILE_ATTRIBUTE_FILESYSTEM_READONLY,+    pattern FILE_ATTRIBUTE_FILESYSTEM_FREE  ,+    pattern FILE_ATTRIBUTE_ETAG_VALUE       ,+    pattern FILE_ATTRIBUTE_DOS_IS_SYSTEM    ,+    pattern FILE_ATTRIBUTE_DOS_IS_ARCHIVE   ,+    pattern FILE_ATTRIBUTE_ACCESS_CAN_WRITE ,+    pattern FILE_ATTRIBUTE_ACCESS_CAN_TRASH ,+    pattern FILE_ATTRIBUTE_ACCESS_CAN_RENAME,+    pattern FILE_ATTRIBUTE_ACCESS_CAN_READ  ,+    pattern FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE,+    pattern FILE_ATTRIBUTE_ACCESS_CAN_DELETE,+    pattern DESKTOP_APP_INFO_LOOKUP_EXTENSION_POINT_NAME,++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+++pattern VOLUME_MONITOR_EXTENSION_POINT_NAME = "gio-volume-monitor" :: T.Text+++pattern VOLUME_IDENTIFIER_KIND_UUID = "uuid" :: T.Text+++pattern VOLUME_IDENTIFIER_KIND_UNIX_DEVICE = "unix-device" :: T.Text+++pattern VOLUME_IDENTIFIER_KIND_NFS_MOUNT = "nfs-mount" :: T.Text+++pattern VOLUME_IDENTIFIER_KIND_LABEL = "label" :: T.Text+++pattern VOLUME_IDENTIFIER_KIND_HAL_UDI = "hal-udi" :: T.Text+++pattern VOLUME_IDENTIFIER_KIND_CLASS = "class" :: T.Text+++pattern VFS_EXTENSION_POINT_NAME = "gio-vfs" :: T.Text+++pattern TLS_DATABASE_PURPOSE_AUTHENTICATE_SERVER = "1.3.6.1.5.5.7.3.1" :: T.Text+++pattern TLS_DATABASE_PURPOSE_AUTHENTICATE_CLIENT = "1.3.6.1.5.5.7.3.2" :: T.Text+++pattern TLS_BACKEND_EXTENSION_POINT_NAME = "gio-tls-backend" :: T.Text+++pattern PROXY_RESOLVER_EXTENSION_POINT_NAME = "gio-proxy-resolver" :: T.Text+++pattern PROXY_EXTENSION_POINT_NAME = "gio-proxy" :: T.Text+++pattern NETWORK_MONITOR_EXTENSION_POINT_NAME = "gio-network-monitor" :: T.Text+++pattern NATIVE_VOLUME_MONITOR_EXTENSION_POINT_NAME = "gio-native-volume-monitor" :: T.Text+++pattern MENU_LINK_SUBMENU = "submenu" :: T.Text+++pattern MENU_LINK_SECTION = "section" :: T.Text+++pattern MENU_ATTRIBUTE_TARGET = "target" :: T.Text+++pattern MENU_ATTRIBUTE_LABEL = "label" :: T.Text+++pattern MENU_ATTRIBUTE_ICON = "icon" :: T.Text+++pattern MENU_ATTRIBUTE_ACTION_NAMESPACE = "action-namespace" :: T.Text+++pattern MENU_ATTRIBUTE_ACTION = "action" :: T.Text+++pattern FILE_ATTRIBUTE_UNIX_UID = "unix::uid" :: T.Text+++pattern FILE_ATTRIBUTE_UNIX_RDEV = "unix::rdev" :: T.Text+++pattern FILE_ATTRIBUTE_UNIX_NLINK = "unix::nlink" :: T.Text+++pattern FILE_ATTRIBUTE_UNIX_MODE = "unix::mode" :: T.Text+++pattern FILE_ATTRIBUTE_UNIX_IS_MOUNTPOINT = "unix::is-mountpoint" :: T.Text+++pattern FILE_ATTRIBUTE_UNIX_INODE = "unix::inode" :: T.Text+++pattern FILE_ATTRIBUTE_UNIX_GID = "unix::gid" :: T.Text+++pattern FILE_ATTRIBUTE_UNIX_DEVICE = "unix::device" :: T.Text+++pattern FILE_ATTRIBUTE_UNIX_BLOCK_SIZE = "unix::block-size" :: T.Text+++pattern FILE_ATTRIBUTE_UNIX_BLOCKS = "unix::blocks" :: T.Text+++pattern FILE_ATTRIBUTE_TRASH_ORIG_PATH = "trash::orig-path" :: T.Text+++pattern FILE_ATTRIBUTE_TRASH_ITEM_COUNT = "trash::item-count" :: T.Text+++pattern FILE_ATTRIBUTE_TRASH_DELETION_DATE = "trash::deletion-date" :: T.Text+++pattern FILE_ATTRIBUTE_TIME_MODIFIED_USEC = "time::modified-usec" :: T.Text+++pattern FILE_ATTRIBUTE_TIME_MODIFIED = "time::modified" :: T.Text+++pattern FILE_ATTRIBUTE_TIME_CREATED_USEC = "time::created-usec" :: T.Text+++pattern FILE_ATTRIBUTE_TIME_CREATED = "time::created" :: T.Text+++pattern FILE_ATTRIBUTE_TIME_CHANGED_USEC = "time::changed-usec" :: T.Text+++pattern FILE_ATTRIBUTE_TIME_CHANGED = "time::changed" :: T.Text+++pattern FILE_ATTRIBUTE_TIME_ACCESS_USEC = "time::access-usec" :: T.Text+++pattern FILE_ATTRIBUTE_TIME_ACCESS = "time::access" :: T.Text+++pattern FILE_ATTRIBUTE_THUMBNAIL_PATH = "thumbnail::path" :: T.Text+++pattern FILE_ATTRIBUTE_THUMBNAIL_IS_VALID = "thumbnail::is-valid" :: T.Text+++pattern FILE_ATTRIBUTE_THUMBNAILING_FAILED = "thumbnail::failed" :: T.Text+++pattern FILE_ATTRIBUTE_STANDARD_TYPE = "standard::type" :: T.Text+++pattern FILE_ATTRIBUTE_STANDARD_TARGET_URI = "standard::target-uri" :: T.Text+++pattern FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET = "standard::symlink-target" :: T.Text+++pattern FILE_ATTRIBUTE_STANDARD_SYMBOLIC_ICON = "standard::symbolic-icon" :: T.Text+++pattern FILE_ATTRIBUTE_STANDARD_SORT_ORDER = "standard::sort-order" :: T.Text+++pattern FILE_ATTRIBUTE_STANDARD_SIZE = "standard::size" :: T.Text+++pattern FILE_ATTRIBUTE_STANDARD_NAME = "standard::name" :: T.Text+++pattern FILE_ATTRIBUTE_STANDARD_IS_VOLATILE = "standard::is-volatile" :: T.Text+++pattern FILE_ATTRIBUTE_STANDARD_IS_VIRTUAL = "standard::is-virtual" :: T.Text+++pattern FILE_ATTRIBUTE_STANDARD_IS_SYMLINK = "standard::is-symlink" :: T.Text+++pattern FILE_ATTRIBUTE_STANDARD_IS_HIDDEN = "standard::is-hidden" :: T.Text+++pattern FILE_ATTRIBUTE_STANDARD_IS_BACKUP = "standard::is-backup" :: T.Text+++pattern FILE_ATTRIBUTE_STANDARD_ICON = "standard::icon" :: T.Text+++pattern FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE = "standard::fast-content-type" :: T.Text+++pattern FILE_ATTRIBUTE_STANDARD_EDIT_NAME = "standard::edit-name" :: T.Text+++pattern FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME = "standard::display-name" :: T.Text+++pattern FILE_ATTRIBUTE_STANDARD_DESCRIPTION = "standard::description" :: T.Text+++pattern FILE_ATTRIBUTE_STANDARD_COPY_NAME = "standard::copy-name" :: T.Text+++pattern FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE = "standard::content-type" :: T.Text+++pattern FILE_ATTRIBUTE_STANDARD_ALLOCATED_SIZE = "standard::allocated-size" :: T.Text+++pattern FILE_ATTRIBUTE_SELINUX_CONTEXT = "selinux::context" :: T.Text+++pattern FILE_ATTRIBUTE_PREVIEW_ICON = "preview::icon" :: T.Text+++pattern FILE_ATTRIBUTE_OWNER_USER_REAL = "owner::user-real" :: T.Text+++pattern FILE_ATTRIBUTE_OWNER_USER = "owner::user" :: T.Text+++pattern FILE_ATTRIBUTE_OWNER_GROUP = "owner::group" :: T.Text+++pattern FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE_FILE = "mountable::unix-device-file" :: T.Text+++pattern FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE = "mountable::unix-device" :: T.Text+++pattern FILE_ATTRIBUTE_MOUNTABLE_START_STOP_TYPE = "mountable::start-stop-type" :: T.Text+++pattern FILE_ATTRIBUTE_MOUNTABLE_IS_MEDIA_CHECK_AUTOMATIC = "mountable::is-media-check-automatic" :: T.Text+++pattern FILE_ATTRIBUTE_MOUNTABLE_HAL_UDI = "mountable::hal-udi" :: T.Text+++pattern FILE_ATTRIBUTE_MOUNTABLE_CAN_UNMOUNT = "mountable::can-unmount" :: T.Text+++pattern FILE_ATTRIBUTE_MOUNTABLE_CAN_STOP = "mountable::can-stop" :: T.Text+++pattern FILE_ATTRIBUTE_MOUNTABLE_CAN_START_DEGRADED = "mountable::can-start-degraded" :: T.Text+++pattern FILE_ATTRIBUTE_MOUNTABLE_CAN_START = "mountable::can-start" :: T.Text+++pattern FILE_ATTRIBUTE_MOUNTABLE_CAN_POLL = "mountable::can-poll" :: T.Text+++pattern FILE_ATTRIBUTE_MOUNTABLE_CAN_MOUNT = "mountable::can-mount" :: T.Text+++pattern FILE_ATTRIBUTE_MOUNTABLE_CAN_EJECT = "mountable::can-eject" :: T.Text+++pattern FILE_ATTRIBUTE_ID_FILESYSTEM = "id::filesystem" :: T.Text+++pattern FILE_ATTRIBUTE_ID_FILE = "id::file" :: T.Text+++pattern FILE_ATTRIBUTE_GVFS_BACKEND = "gvfs::backend" :: T.Text+++pattern FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW = "filesystem::use-preview" :: T.Text+++pattern FILE_ATTRIBUTE_FILESYSTEM_USED = "filesystem::used" :: T.Text+++pattern FILE_ATTRIBUTE_FILESYSTEM_TYPE = "filesystem::type" :: T.Text+++pattern FILE_ATTRIBUTE_FILESYSTEM_SIZE = "filesystem::size" :: T.Text+++pattern FILE_ATTRIBUTE_FILESYSTEM_READONLY = "filesystem::readonly" :: T.Text+++pattern FILE_ATTRIBUTE_FILESYSTEM_FREE = "filesystem::free" :: T.Text+++pattern FILE_ATTRIBUTE_ETAG_VALUE = "etag::value" :: T.Text+++pattern FILE_ATTRIBUTE_DOS_IS_SYSTEM = "dos::is-system" :: T.Text+++pattern FILE_ATTRIBUTE_DOS_IS_ARCHIVE = "dos::is-archive" :: T.Text+++pattern FILE_ATTRIBUTE_ACCESS_CAN_WRITE = "access::can-write" :: T.Text+++pattern FILE_ATTRIBUTE_ACCESS_CAN_TRASH = "access::can-trash" :: T.Text+++pattern FILE_ATTRIBUTE_ACCESS_CAN_RENAME = "access::can-rename" :: T.Text+++pattern FILE_ATTRIBUTE_ACCESS_CAN_READ = "access::can-read" :: T.Text+++pattern FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE = "access::can-execute" :: T.Text+++pattern FILE_ATTRIBUTE_ACCESS_CAN_DELETE = "access::can-delete" :: T.Text+++pattern DESKTOP_APP_INFO_LOOKUP_EXTENSION_POINT_NAME = "gio-desktop-app-info-lookup" :: T.Text++
+ GI/Gio/Enums.hs view
@@ -0,0 +1,1550 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Enums+    ( +    catchTlsError                           ,+    handleTlsError                          ,+    catchResourceError                      ,+    handleResourceError                     ,+    catchResolverError                      ,+    handleResolverError                     ,+    catchIOErrorEnum                        ,+    handleIOErrorEnum                       ,+    catchDBusError                          ,+    handleDBusError                         ,++-- * Exported types+    ZlibCompressorFormat(..)                ,+    UnixSocketAddressType(..)               ,+    TlsRehandshakeMode(..)                  ,+    TlsInteractionResult(..)                ,+    TlsError(..)                            ,+    TlsDatabaseLookupFlags(..)              ,+    TlsCertificateRequestFlags(..)          ,+    TlsAuthenticationMode(..)               ,+    SocketType(..)                          ,+    SocketProtocol(..)                      ,+    SocketListenerEvent(..)                 ,+    SocketFamily(..)                        ,+    SocketClientEvent(..)                   ,+    ResourceError(..)                       ,+    ResolverRecordType(..)                  ,+    ResolverError(..)                       ,+    PasswordSave(..)                        ,+    NotificationPriority(..)                ,+    NetworkConnectivity(..)                 ,+    MountOperationResult(..)                ,+    IOModuleScopeFlags(..)                  ,+    IOErrorEnum(..)                         ,+    FilesystemPreviewType(..)               ,+    FileType(..)                            ,+    FileMonitorEvent(..)                    ,+    FileAttributeType(..)                   ,+    FileAttributeStatus(..)                 ,+    EmblemOrigin(..)                        ,+    DriveStartStopType(..)                  ,+    DataStreamNewlineType(..)               ,+    DataStreamByteOrder(..)                 ,+    DBusMessageType(..)                     ,+    DBusMessageHeaderField(..)              ,+    DBusMessageByteOrder(..)                ,+    DBusError(..)                           ,+    CredentialsType(..)                     ,+    ConverterResult(..)                     ,+    BusType(..)                             ,+++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+++++-- Enum ZlibCompressorFormat++data ZlibCompressorFormat = +      ZlibCompressorFormatZlib+    | ZlibCompressorFormatGzip+    | ZlibCompressorFormatRaw+    | AnotherZlibCompressorFormat Int+    deriving (Show, Eq)++instance Enum ZlibCompressorFormat where+    fromEnum ZlibCompressorFormatZlib = 0+    fromEnum ZlibCompressorFormatGzip = 1+    fromEnum ZlibCompressorFormatRaw = 2+    fromEnum (AnotherZlibCompressorFormat k) = k++    toEnum 0 = ZlibCompressorFormatZlib+    toEnum 1 = ZlibCompressorFormatGzip+    toEnum 2 = ZlibCompressorFormatRaw+    toEnum k = AnotherZlibCompressorFormat k++foreign import ccall "g_zlib_compressor_format_get_type" c_g_zlib_compressor_format_get_type :: +    IO GType++instance BoxedEnum ZlibCompressorFormat where+    boxedEnumType _ = c_g_zlib_compressor_format_get_type++-- Enum UnixSocketAddressType++data UnixSocketAddressType = +      UnixSocketAddressTypeInvalid+    | UnixSocketAddressTypeAnonymous+    | UnixSocketAddressTypePath+    | UnixSocketAddressTypeAbstract+    | UnixSocketAddressTypeAbstractPadded+    | AnotherUnixSocketAddressType Int+    deriving (Show, Eq)++instance Enum UnixSocketAddressType where+    fromEnum UnixSocketAddressTypeInvalid = 0+    fromEnum UnixSocketAddressTypeAnonymous = 1+    fromEnum UnixSocketAddressTypePath = 2+    fromEnum UnixSocketAddressTypeAbstract = 3+    fromEnum UnixSocketAddressTypeAbstractPadded = 4+    fromEnum (AnotherUnixSocketAddressType k) = k++    toEnum 0 = UnixSocketAddressTypeInvalid+    toEnum 1 = UnixSocketAddressTypeAnonymous+    toEnum 2 = UnixSocketAddressTypePath+    toEnum 3 = UnixSocketAddressTypeAbstract+    toEnum 4 = UnixSocketAddressTypeAbstractPadded+    toEnum k = AnotherUnixSocketAddressType k++foreign import ccall "g_unix_socket_address_type_get_type" c_g_unix_socket_address_type_get_type :: +    IO GType++instance BoxedEnum UnixSocketAddressType where+    boxedEnumType _ = c_g_unix_socket_address_type_get_type++-- Enum TlsRehandshakeMode++data TlsRehandshakeMode = +      TlsRehandshakeModeNever+    | TlsRehandshakeModeSafely+    | TlsRehandshakeModeUnsafely+    | AnotherTlsRehandshakeMode Int+    deriving (Show, Eq)++instance Enum TlsRehandshakeMode where+    fromEnum TlsRehandshakeModeNever = 0+    fromEnum TlsRehandshakeModeSafely = 1+    fromEnum TlsRehandshakeModeUnsafely = 2+    fromEnum (AnotherTlsRehandshakeMode k) = k++    toEnum 0 = TlsRehandshakeModeNever+    toEnum 1 = TlsRehandshakeModeSafely+    toEnum 2 = TlsRehandshakeModeUnsafely+    toEnum k = AnotherTlsRehandshakeMode k++foreign import ccall "g_tls_rehandshake_mode_get_type" c_g_tls_rehandshake_mode_get_type :: +    IO GType++instance BoxedEnum TlsRehandshakeMode where+    boxedEnumType _ = c_g_tls_rehandshake_mode_get_type++-- Enum TlsInteractionResult++data TlsInteractionResult = +      TlsInteractionResultUnhandled+    | TlsInteractionResultHandled+    | TlsInteractionResultFailed+    | AnotherTlsInteractionResult Int+    deriving (Show, Eq)++instance Enum TlsInteractionResult where+    fromEnum TlsInteractionResultUnhandled = 0+    fromEnum TlsInteractionResultHandled = 1+    fromEnum TlsInteractionResultFailed = 2+    fromEnum (AnotherTlsInteractionResult k) = k++    toEnum 0 = TlsInteractionResultUnhandled+    toEnum 1 = TlsInteractionResultHandled+    toEnum 2 = TlsInteractionResultFailed+    toEnum k = AnotherTlsInteractionResult k++foreign import ccall "g_tls_interaction_result_get_type" c_g_tls_interaction_result_get_type :: +    IO GType++instance BoxedEnum TlsInteractionResult where+    boxedEnumType _ = c_g_tls_interaction_result_get_type++-- Enum TlsError++data TlsError = +      TlsErrorUnavailable+    | TlsErrorMisc+    | TlsErrorBadCertificate+    | TlsErrorNotTls+    | TlsErrorHandshake+    | TlsErrorCertificateRequired+    | TlsErrorEof+    | AnotherTlsError Int+    deriving (Show, Eq)++instance Enum TlsError where+    fromEnum TlsErrorUnavailable = 0+    fromEnum TlsErrorMisc = 1+    fromEnum TlsErrorBadCertificate = 2+    fromEnum TlsErrorNotTls = 3+    fromEnum TlsErrorHandshake = 4+    fromEnum TlsErrorCertificateRequired = 5+    fromEnum TlsErrorEof = 6+    fromEnum (AnotherTlsError k) = k++    toEnum 0 = TlsErrorUnavailable+    toEnum 1 = TlsErrorMisc+    toEnum 2 = TlsErrorBadCertificate+    toEnum 3 = TlsErrorNotTls+    toEnum 4 = TlsErrorHandshake+    toEnum 5 = TlsErrorCertificateRequired+    toEnum 6 = TlsErrorEof+    toEnum k = AnotherTlsError k++instance GErrorClass TlsError where+    gerrorClassDomain _ = "g-tls-error-quark"++catchTlsError ::+    IO a ->+    (TlsError -> GErrorMessage -> IO a) ->+    IO a+catchTlsError = catchGErrorJustDomain++handleTlsError ::+    (TlsError -> GErrorMessage -> IO a) ->+    IO a ->+    IO a+handleTlsError = handleGErrorJustDomain++foreign import ccall "g_tls_error_get_type" c_g_tls_error_get_type :: +    IO GType++instance BoxedEnum TlsError where+    boxedEnumType _ = c_g_tls_error_get_type++-- Enum TlsDatabaseLookupFlags++data TlsDatabaseLookupFlags = +      TlsDatabaseLookupFlagsNone+    | TlsDatabaseLookupFlagsKeypair+    | AnotherTlsDatabaseLookupFlags Int+    deriving (Show, Eq)++instance Enum TlsDatabaseLookupFlags where+    fromEnum TlsDatabaseLookupFlagsNone = 0+    fromEnum TlsDatabaseLookupFlagsKeypair = 1+    fromEnum (AnotherTlsDatabaseLookupFlags k) = k++    toEnum 0 = TlsDatabaseLookupFlagsNone+    toEnum 1 = TlsDatabaseLookupFlagsKeypair+    toEnum k = AnotherTlsDatabaseLookupFlags k++foreign import ccall "g_tls_database_lookup_flags_get_type" c_g_tls_database_lookup_flags_get_type :: +    IO GType++instance BoxedEnum TlsDatabaseLookupFlags where+    boxedEnumType _ = c_g_tls_database_lookup_flags_get_type++-- Enum TlsCertificateRequestFlags++data TlsCertificateRequestFlags = +      TlsCertificateRequestFlagsNone+    | AnotherTlsCertificateRequestFlags Int+    deriving (Show, Eq)++instance Enum TlsCertificateRequestFlags where+    fromEnum TlsCertificateRequestFlagsNone = 0+    fromEnum (AnotherTlsCertificateRequestFlags k) = k++    toEnum 0 = TlsCertificateRequestFlagsNone+    toEnum k = AnotherTlsCertificateRequestFlags k++foreign import ccall "g_tls_certificate_request_flags_get_type" c_g_tls_certificate_request_flags_get_type :: +    IO GType++instance BoxedEnum TlsCertificateRequestFlags where+    boxedEnumType _ = c_g_tls_certificate_request_flags_get_type++-- Enum TlsAuthenticationMode++data TlsAuthenticationMode = +      TlsAuthenticationModeNone+    | TlsAuthenticationModeRequested+    | TlsAuthenticationModeRequired+    | AnotherTlsAuthenticationMode Int+    deriving (Show, Eq)++instance Enum TlsAuthenticationMode where+    fromEnum TlsAuthenticationModeNone = 0+    fromEnum TlsAuthenticationModeRequested = 1+    fromEnum TlsAuthenticationModeRequired = 2+    fromEnum (AnotherTlsAuthenticationMode k) = k++    toEnum 0 = TlsAuthenticationModeNone+    toEnum 1 = TlsAuthenticationModeRequested+    toEnum 2 = TlsAuthenticationModeRequired+    toEnum k = AnotherTlsAuthenticationMode k++foreign import ccall "g_tls_authentication_mode_get_type" c_g_tls_authentication_mode_get_type :: +    IO GType++instance BoxedEnum TlsAuthenticationMode where+    boxedEnumType _ = c_g_tls_authentication_mode_get_type++-- Enum SocketType++data SocketType = +      SocketTypeInvalid+    | SocketTypeStream+    | SocketTypeDatagram+    | SocketTypeSeqpacket+    | AnotherSocketType Int+    deriving (Show, Eq)++instance Enum SocketType where+    fromEnum SocketTypeInvalid = 0+    fromEnum SocketTypeStream = 1+    fromEnum SocketTypeDatagram = 2+    fromEnum SocketTypeSeqpacket = 3+    fromEnum (AnotherSocketType k) = k++    toEnum 0 = SocketTypeInvalid+    toEnum 1 = SocketTypeStream+    toEnum 2 = SocketTypeDatagram+    toEnum 3 = SocketTypeSeqpacket+    toEnum k = AnotherSocketType k++foreign import ccall "g_socket_type_get_type" c_g_socket_type_get_type :: +    IO GType++instance BoxedEnum SocketType where+    boxedEnumType _ = c_g_socket_type_get_type++-- Enum SocketProtocol++data SocketProtocol = +      SocketProtocolUnknown+    | SocketProtocolDefault+    | SocketProtocolTcp+    | SocketProtocolUdp+    | SocketProtocolSctp+    | AnotherSocketProtocol Int+    deriving (Show, Eq)++instance Enum SocketProtocol where+    fromEnum SocketProtocolUnknown = -1+    fromEnum SocketProtocolDefault = 0+    fromEnum SocketProtocolTcp = 6+    fromEnum SocketProtocolUdp = 17+    fromEnum SocketProtocolSctp = 132+    fromEnum (AnotherSocketProtocol k) = k++    toEnum -1 = SocketProtocolUnknown+    toEnum 0 = SocketProtocolDefault+    toEnum 6 = SocketProtocolTcp+    toEnum 17 = SocketProtocolUdp+    toEnum 132 = SocketProtocolSctp+    toEnum k = AnotherSocketProtocol k++foreign import ccall "g_socket_protocol_get_type" c_g_socket_protocol_get_type :: +    IO GType++instance BoxedEnum SocketProtocol where+    boxedEnumType _ = c_g_socket_protocol_get_type++-- Enum SocketListenerEvent++data SocketListenerEvent = +      SocketListenerEventBinding+    | SocketListenerEventBound+    | SocketListenerEventListening+    | SocketListenerEventListened+    | AnotherSocketListenerEvent Int+    deriving (Show, Eq)++instance Enum SocketListenerEvent where+    fromEnum SocketListenerEventBinding = 0+    fromEnum SocketListenerEventBound = 1+    fromEnum SocketListenerEventListening = 2+    fromEnum SocketListenerEventListened = 3+    fromEnum (AnotherSocketListenerEvent k) = k++    toEnum 0 = SocketListenerEventBinding+    toEnum 1 = SocketListenerEventBound+    toEnum 2 = SocketListenerEventListening+    toEnum 3 = SocketListenerEventListened+    toEnum k = AnotherSocketListenerEvent k++foreign import ccall "g_socket_listener_event_get_type" c_g_socket_listener_event_get_type :: +    IO GType++instance BoxedEnum SocketListenerEvent where+    boxedEnumType _ = c_g_socket_listener_event_get_type++-- Enum SocketFamily++data SocketFamily = +      SocketFamilyInvalid+    | SocketFamilyUnix+    | SocketFamilyIpv4+    | SocketFamilyIpv6+    | AnotherSocketFamily Int+    deriving (Show, Eq)++instance Enum SocketFamily where+    fromEnum SocketFamilyInvalid = 0+    fromEnum SocketFamilyUnix = 1+    fromEnum SocketFamilyIpv4 = 2+    fromEnum SocketFamilyIpv6 = 10+    fromEnum (AnotherSocketFamily k) = k++    toEnum 0 = SocketFamilyInvalid+    toEnum 1 = SocketFamilyUnix+    toEnum 2 = SocketFamilyIpv4+    toEnum 10 = SocketFamilyIpv6+    toEnum k = AnotherSocketFamily k++foreign import ccall "g_socket_family_get_type" c_g_socket_family_get_type :: +    IO GType++instance BoxedEnum SocketFamily where+    boxedEnumType _ = c_g_socket_family_get_type++-- Enum SocketClientEvent++data SocketClientEvent = +      SocketClientEventResolving+    | SocketClientEventResolved+    | SocketClientEventConnecting+    | SocketClientEventConnected+    | SocketClientEventProxyNegotiating+    | SocketClientEventProxyNegotiated+    | SocketClientEventTlsHandshaking+    | SocketClientEventTlsHandshaked+    | SocketClientEventComplete+    | AnotherSocketClientEvent Int+    deriving (Show, Eq)++instance Enum SocketClientEvent where+    fromEnum SocketClientEventResolving = 0+    fromEnum SocketClientEventResolved = 1+    fromEnum SocketClientEventConnecting = 2+    fromEnum SocketClientEventConnected = 3+    fromEnum SocketClientEventProxyNegotiating = 4+    fromEnum SocketClientEventProxyNegotiated = 5+    fromEnum SocketClientEventTlsHandshaking = 6+    fromEnum SocketClientEventTlsHandshaked = 7+    fromEnum SocketClientEventComplete = 8+    fromEnum (AnotherSocketClientEvent k) = k++    toEnum 0 = SocketClientEventResolving+    toEnum 1 = SocketClientEventResolved+    toEnum 2 = SocketClientEventConnecting+    toEnum 3 = SocketClientEventConnected+    toEnum 4 = SocketClientEventProxyNegotiating+    toEnum 5 = SocketClientEventProxyNegotiated+    toEnum 6 = SocketClientEventTlsHandshaking+    toEnum 7 = SocketClientEventTlsHandshaked+    toEnum 8 = SocketClientEventComplete+    toEnum k = AnotherSocketClientEvent k++foreign import ccall "g_socket_client_event_get_type" c_g_socket_client_event_get_type :: +    IO GType++instance BoxedEnum SocketClientEvent where+    boxedEnumType _ = c_g_socket_client_event_get_type++-- Enum ResourceError++data ResourceError = +      ResourceErrorNotFound+    | ResourceErrorInternal+    | AnotherResourceError Int+    deriving (Show, Eq)++instance Enum ResourceError where+    fromEnum ResourceErrorNotFound = 0+    fromEnum ResourceErrorInternal = 1+    fromEnum (AnotherResourceError k) = k++    toEnum 0 = ResourceErrorNotFound+    toEnum 1 = ResourceErrorInternal+    toEnum k = AnotherResourceError k++instance GErrorClass ResourceError where+    gerrorClassDomain _ = "g-resource-error-quark"++catchResourceError ::+    IO a ->+    (ResourceError -> GErrorMessage -> IO a) ->+    IO a+catchResourceError = catchGErrorJustDomain++handleResourceError ::+    (ResourceError -> GErrorMessage -> IO a) ->+    IO a ->+    IO a+handleResourceError = handleGErrorJustDomain++foreign import ccall "g_resource_error_get_type" c_g_resource_error_get_type :: +    IO GType++instance BoxedEnum ResourceError where+    boxedEnumType _ = c_g_resource_error_get_type++-- Enum ResolverRecordType++data ResolverRecordType = +      ResolverRecordTypeSrv+    | ResolverRecordTypeMx+    | ResolverRecordTypeTxt+    | ResolverRecordTypeSoa+    | ResolverRecordTypeNs+    | AnotherResolverRecordType Int+    deriving (Show, Eq)++instance Enum ResolverRecordType where+    fromEnum ResolverRecordTypeSrv = 1+    fromEnum ResolverRecordTypeMx = 2+    fromEnum ResolverRecordTypeTxt = 3+    fromEnum ResolverRecordTypeSoa = 4+    fromEnum ResolverRecordTypeNs = 5+    fromEnum (AnotherResolverRecordType k) = k++    toEnum 1 = ResolverRecordTypeSrv+    toEnum 2 = ResolverRecordTypeMx+    toEnum 3 = ResolverRecordTypeTxt+    toEnum 4 = ResolverRecordTypeSoa+    toEnum 5 = ResolverRecordTypeNs+    toEnum k = AnotherResolverRecordType k++foreign import ccall "g_resolver_record_type_get_type" c_g_resolver_record_type_get_type :: +    IO GType++instance BoxedEnum ResolverRecordType where+    boxedEnumType _ = c_g_resolver_record_type_get_type++-- Enum ResolverError++data ResolverError = +      ResolverErrorNotFound+    | ResolverErrorTemporaryFailure+    | ResolverErrorInternal+    | AnotherResolverError Int+    deriving (Show, Eq)++instance Enum ResolverError where+    fromEnum ResolverErrorNotFound = 0+    fromEnum ResolverErrorTemporaryFailure = 1+    fromEnum ResolverErrorInternal = 2+    fromEnum (AnotherResolverError k) = k++    toEnum 0 = ResolverErrorNotFound+    toEnum 1 = ResolverErrorTemporaryFailure+    toEnum 2 = ResolverErrorInternal+    toEnum k = AnotherResolverError k++instance GErrorClass ResolverError where+    gerrorClassDomain _ = "g-resolver-error-quark"++catchResolverError ::+    IO a ->+    (ResolverError -> GErrorMessage -> IO a) ->+    IO a+catchResolverError = catchGErrorJustDomain++handleResolverError ::+    (ResolverError -> GErrorMessage -> IO a) ->+    IO a ->+    IO a+handleResolverError = handleGErrorJustDomain++foreign import ccall "g_resolver_error_get_type" c_g_resolver_error_get_type :: +    IO GType++instance BoxedEnum ResolverError where+    boxedEnumType _ = c_g_resolver_error_get_type++-- Enum PasswordSave++data PasswordSave = +      PasswordSaveNever+    | PasswordSaveForSession+    | PasswordSavePermanently+    | AnotherPasswordSave Int+    deriving (Show, Eq)++instance Enum PasswordSave where+    fromEnum PasswordSaveNever = 0+    fromEnum PasswordSaveForSession = 1+    fromEnum PasswordSavePermanently = 2+    fromEnum (AnotherPasswordSave k) = k++    toEnum 0 = PasswordSaveNever+    toEnum 1 = PasswordSaveForSession+    toEnum 2 = PasswordSavePermanently+    toEnum k = AnotherPasswordSave k++foreign import ccall "g_password_save_get_type" c_g_password_save_get_type :: +    IO GType++instance BoxedEnum PasswordSave where+    boxedEnumType _ = c_g_password_save_get_type++-- Enum NotificationPriority++data NotificationPriority = +      NotificationPriorityNormal+    | NotificationPriorityLow+    | NotificationPriorityHigh+    | NotificationPriorityUrgent+    | AnotherNotificationPriority Int+    deriving (Show, Eq)++instance Enum NotificationPriority where+    fromEnum NotificationPriorityNormal = 0+    fromEnum NotificationPriorityLow = 1+    fromEnum NotificationPriorityHigh = 2+    fromEnum NotificationPriorityUrgent = 3+    fromEnum (AnotherNotificationPriority k) = k++    toEnum 0 = NotificationPriorityNormal+    toEnum 1 = NotificationPriorityLow+    toEnum 2 = NotificationPriorityHigh+    toEnum 3 = NotificationPriorityUrgent+    toEnum k = AnotherNotificationPriority k++foreign import ccall "g_notification_priority_get_type" c_g_notification_priority_get_type :: +    IO GType++instance BoxedEnum NotificationPriority where+    boxedEnumType _ = c_g_notification_priority_get_type++-- Enum NetworkConnectivity++data NetworkConnectivity = +      NetworkConnectivityLocal+    | NetworkConnectivityLimited+    | NetworkConnectivityPortal+    | NetworkConnectivityFull+    | AnotherNetworkConnectivity Int+    deriving (Show, Eq)++instance Enum NetworkConnectivity where+    fromEnum NetworkConnectivityLocal = 1+    fromEnum NetworkConnectivityLimited = 2+    fromEnum NetworkConnectivityPortal = 3+    fromEnum NetworkConnectivityFull = 4+    fromEnum (AnotherNetworkConnectivity k) = k++    toEnum 1 = NetworkConnectivityLocal+    toEnum 2 = NetworkConnectivityLimited+    toEnum 3 = NetworkConnectivityPortal+    toEnum 4 = NetworkConnectivityFull+    toEnum k = AnotherNetworkConnectivity k++foreign import ccall "g_network_connectivity_get_type" c_g_network_connectivity_get_type :: +    IO GType++instance BoxedEnum NetworkConnectivity where+    boxedEnumType _ = c_g_network_connectivity_get_type++-- Enum MountOperationResult++data MountOperationResult = +      MountOperationResultHandled+    | MountOperationResultAborted+    | MountOperationResultUnhandled+    | AnotherMountOperationResult Int+    deriving (Show, Eq)++instance Enum MountOperationResult where+    fromEnum MountOperationResultHandled = 0+    fromEnum MountOperationResultAborted = 1+    fromEnum MountOperationResultUnhandled = 2+    fromEnum (AnotherMountOperationResult k) = k++    toEnum 0 = MountOperationResultHandled+    toEnum 1 = MountOperationResultAborted+    toEnum 2 = MountOperationResultUnhandled+    toEnum k = AnotherMountOperationResult k++foreign import ccall "g_mount_operation_result_get_type" c_g_mount_operation_result_get_type :: +    IO GType++instance BoxedEnum MountOperationResult where+    boxedEnumType _ = c_g_mount_operation_result_get_type++-- Enum IOModuleScopeFlags++data IOModuleScopeFlags = +      IOModuleScopeFlagsNone+    | IOModuleScopeFlagsBlockDuplicates+    | AnotherIOModuleScopeFlags Int+    deriving (Show, Eq)++instance Enum IOModuleScopeFlags where+    fromEnum IOModuleScopeFlagsNone = 0+    fromEnum IOModuleScopeFlagsBlockDuplicates = 1+    fromEnum (AnotherIOModuleScopeFlags k) = k++    toEnum 0 = IOModuleScopeFlagsNone+    toEnum 1 = IOModuleScopeFlagsBlockDuplicates+    toEnum k = AnotherIOModuleScopeFlags k++foreign import ccall "g_io_module_scope_flags_get_type" c_g_io_module_scope_flags_get_type :: +    IO GType++instance BoxedEnum IOModuleScopeFlags where+    boxedEnumType _ = c_g_io_module_scope_flags_get_type++-- Enum IOErrorEnum++data IOErrorEnum = +      IOErrorEnumFailed+    | IOErrorEnumNotFound+    | IOErrorEnumExists+    | IOErrorEnumIsDirectory+    | IOErrorEnumNotDirectory+    | IOErrorEnumNotEmpty+    | IOErrorEnumNotRegularFile+    | IOErrorEnumNotSymbolicLink+    | IOErrorEnumNotMountableFile+    | IOErrorEnumFilenameTooLong+    | IOErrorEnumInvalidFilename+    | IOErrorEnumTooManyLinks+    | IOErrorEnumNoSpace+    | IOErrorEnumInvalidArgument+    | IOErrorEnumPermissionDenied+    | IOErrorEnumNotSupported+    | IOErrorEnumNotMounted+    | IOErrorEnumAlreadyMounted+    | IOErrorEnumClosed+    | IOErrorEnumCancelled+    | IOErrorEnumPending+    | IOErrorEnumReadOnly+    | IOErrorEnumCantCreateBackup+    | IOErrorEnumWrongEtag+    | IOErrorEnumTimedOut+    | IOErrorEnumWouldRecurse+    | IOErrorEnumBusy+    | IOErrorEnumWouldBlock+    | IOErrorEnumHostNotFound+    | IOErrorEnumWouldMerge+    | IOErrorEnumFailedHandled+    | IOErrorEnumTooManyOpenFiles+    | IOErrorEnumNotInitialized+    | IOErrorEnumAddressInUse+    | IOErrorEnumPartialInput+    | IOErrorEnumInvalidData+    | IOErrorEnumDbusError+    | IOErrorEnumHostUnreachable+    | IOErrorEnumNetworkUnreachable+    | IOErrorEnumConnectionRefused+    | IOErrorEnumProxyFailed+    | IOErrorEnumProxyAuthFailed+    | IOErrorEnumProxyNeedAuth+    | IOErrorEnumProxyNotAllowed+    | IOErrorEnumBrokenPipe+    | IOErrorEnumConnectionClosed+    | IOErrorEnumNotConnected+    | AnotherIOErrorEnum Int+    deriving (Show, Eq)++instance Enum IOErrorEnum where+    fromEnum IOErrorEnumFailed = 0+    fromEnum IOErrorEnumNotFound = 1+    fromEnum IOErrorEnumExists = 2+    fromEnum IOErrorEnumIsDirectory = 3+    fromEnum IOErrorEnumNotDirectory = 4+    fromEnum IOErrorEnumNotEmpty = 5+    fromEnum IOErrorEnumNotRegularFile = 6+    fromEnum IOErrorEnumNotSymbolicLink = 7+    fromEnum IOErrorEnumNotMountableFile = 8+    fromEnum IOErrorEnumFilenameTooLong = 9+    fromEnum IOErrorEnumInvalidFilename = 10+    fromEnum IOErrorEnumTooManyLinks = 11+    fromEnum IOErrorEnumNoSpace = 12+    fromEnum IOErrorEnumInvalidArgument = 13+    fromEnum IOErrorEnumPermissionDenied = 14+    fromEnum IOErrorEnumNotSupported = 15+    fromEnum IOErrorEnumNotMounted = 16+    fromEnum IOErrorEnumAlreadyMounted = 17+    fromEnum IOErrorEnumClosed = 18+    fromEnum IOErrorEnumCancelled = 19+    fromEnum IOErrorEnumPending = 20+    fromEnum IOErrorEnumReadOnly = 21+    fromEnum IOErrorEnumCantCreateBackup = 22+    fromEnum IOErrorEnumWrongEtag = 23+    fromEnum IOErrorEnumTimedOut = 24+    fromEnum IOErrorEnumWouldRecurse = 25+    fromEnum IOErrorEnumBusy = 26+    fromEnum IOErrorEnumWouldBlock = 27+    fromEnum IOErrorEnumHostNotFound = 28+    fromEnum IOErrorEnumWouldMerge = 29+    fromEnum IOErrorEnumFailedHandled = 30+    fromEnum IOErrorEnumTooManyOpenFiles = 31+    fromEnum IOErrorEnumNotInitialized = 32+    fromEnum IOErrorEnumAddressInUse = 33+    fromEnum IOErrorEnumPartialInput = 34+    fromEnum IOErrorEnumInvalidData = 35+    fromEnum IOErrorEnumDbusError = 36+    fromEnum IOErrorEnumHostUnreachable = 37+    fromEnum IOErrorEnumNetworkUnreachable = 38+    fromEnum IOErrorEnumConnectionRefused = 39+    fromEnum IOErrorEnumProxyFailed = 40+    fromEnum IOErrorEnumProxyAuthFailed = 41+    fromEnum IOErrorEnumProxyNeedAuth = 42+    fromEnum IOErrorEnumProxyNotAllowed = 43+    fromEnum IOErrorEnumBrokenPipe = 44+    fromEnum IOErrorEnumConnectionClosed = 44+    fromEnum IOErrorEnumNotConnected = 45+    fromEnum (AnotherIOErrorEnum k) = k++    toEnum 0 = IOErrorEnumFailed+    toEnum 1 = IOErrorEnumNotFound+    toEnum 2 = IOErrorEnumExists+    toEnum 3 = IOErrorEnumIsDirectory+    toEnum 4 = IOErrorEnumNotDirectory+    toEnum 5 = IOErrorEnumNotEmpty+    toEnum 6 = IOErrorEnumNotRegularFile+    toEnum 7 = IOErrorEnumNotSymbolicLink+    toEnum 8 = IOErrorEnumNotMountableFile+    toEnum 9 = IOErrorEnumFilenameTooLong+    toEnum 10 = IOErrorEnumInvalidFilename+    toEnum 11 = IOErrorEnumTooManyLinks+    toEnum 12 = IOErrorEnumNoSpace+    toEnum 13 = IOErrorEnumInvalidArgument+    toEnum 14 = IOErrorEnumPermissionDenied+    toEnum 15 = IOErrorEnumNotSupported+    toEnum 16 = IOErrorEnumNotMounted+    toEnum 17 = IOErrorEnumAlreadyMounted+    toEnum 18 = IOErrorEnumClosed+    toEnum 19 = IOErrorEnumCancelled+    toEnum 20 = IOErrorEnumPending+    toEnum 21 = IOErrorEnumReadOnly+    toEnum 22 = IOErrorEnumCantCreateBackup+    toEnum 23 = IOErrorEnumWrongEtag+    toEnum 24 = IOErrorEnumTimedOut+    toEnum 25 = IOErrorEnumWouldRecurse+    toEnum 26 = IOErrorEnumBusy+    toEnum 27 = IOErrorEnumWouldBlock+    toEnum 28 = IOErrorEnumHostNotFound+    toEnum 29 = IOErrorEnumWouldMerge+    toEnum 30 = IOErrorEnumFailedHandled+    toEnum 31 = IOErrorEnumTooManyOpenFiles+    toEnum 32 = IOErrorEnumNotInitialized+    toEnum 33 = IOErrorEnumAddressInUse+    toEnum 34 = IOErrorEnumPartialInput+    toEnum 35 = IOErrorEnumInvalidData+    toEnum 36 = IOErrorEnumDbusError+    toEnum 37 = IOErrorEnumHostUnreachable+    toEnum 38 = IOErrorEnumNetworkUnreachable+    toEnum 39 = IOErrorEnumConnectionRefused+    toEnum 40 = IOErrorEnumProxyFailed+    toEnum 41 = IOErrorEnumProxyAuthFailed+    toEnum 42 = IOErrorEnumProxyNeedAuth+    toEnum 43 = IOErrorEnumProxyNotAllowed+    toEnum 44 = IOErrorEnumBrokenPipe+    toEnum 45 = IOErrorEnumNotConnected+    toEnum k = AnotherIOErrorEnum k++instance GErrorClass IOErrorEnum where+    gerrorClassDomain _ = "g-io-error-quark"++catchIOErrorEnum ::+    IO a ->+    (IOErrorEnum -> GErrorMessage -> IO a) ->+    IO a+catchIOErrorEnum = catchGErrorJustDomain++handleIOErrorEnum ::+    (IOErrorEnum -> GErrorMessage -> IO a) ->+    IO a ->+    IO a+handleIOErrorEnum = handleGErrorJustDomain++foreign import ccall "g_io_error_enum_get_type" c_g_io_error_enum_get_type :: +    IO GType++instance BoxedEnum IOErrorEnum where+    boxedEnumType _ = c_g_io_error_enum_get_type++-- Enum FilesystemPreviewType++data FilesystemPreviewType = +      FilesystemPreviewTypeIfAlways+    | FilesystemPreviewTypeIfLocal+    | FilesystemPreviewTypeNever+    | AnotherFilesystemPreviewType Int+    deriving (Show, Eq)++instance Enum FilesystemPreviewType where+    fromEnum FilesystemPreviewTypeIfAlways = 0+    fromEnum FilesystemPreviewTypeIfLocal = 1+    fromEnum FilesystemPreviewTypeNever = 2+    fromEnum (AnotherFilesystemPreviewType k) = k++    toEnum 0 = FilesystemPreviewTypeIfAlways+    toEnum 1 = FilesystemPreviewTypeIfLocal+    toEnum 2 = FilesystemPreviewTypeNever+    toEnum k = AnotherFilesystemPreviewType k++foreign import ccall "g_filesystem_preview_type_get_type" c_g_filesystem_preview_type_get_type :: +    IO GType++instance BoxedEnum FilesystemPreviewType where+    boxedEnumType _ = c_g_filesystem_preview_type_get_type++-- Enum FileType++data FileType = +      FileTypeUnknown+    | FileTypeRegular+    | FileTypeDirectory+    | FileTypeSymbolicLink+    | FileTypeSpecial+    | FileTypeShortcut+    | FileTypeMountable+    | AnotherFileType Int+    deriving (Show, Eq)++instance Enum FileType where+    fromEnum FileTypeUnknown = 0+    fromEnum FileTypeRegular = 1+    fromEnum FileTypeDirectory = 2+    fromEnum FileTypeSymbolicLink = 3+    fromEnum FileTypeSpecial = 4+    fromEnum FileTypeShortcut = 5+    fromEnum FileTypeMountable = 6+    fromEnum (AnotherFileType k) = k++    toEnum 0 = FileTypeUnknown+    toEnum 1 = FileTypeRegular+    toEnum 2 = FileTypeDirectory+    toEnum 3 = FileTypeSymbolicLink+    toEnum 4 = FileTypeSpecial+    toEnum 5 = FileTypeShortcut+    toEnum 6 = FileTypeMountable+    toEnum k = AnotherFileType k++foreign import ccall "g_file_type_get_type" c_g_file_type_get_type :: +    IO GType++instance BoxedEnum FileType where+    boxedEnumType _ = c_g_file_type_get_type++-- Enum FileMonitorEvent++data FileMonitorEvent = +      FileMonitorEventChanged+    | FileMonitorEventChangesDoneHint+    | FileMonitorEventDeleted+    | FileMonitorEventCreated+    | FileMonitorEventAttributeChanged+    | FileMonitorEventPreUnmount+    | FileMonitorEventUnmounted+    | FileMonitorEventMoved+    | FileMonitorEventRenamed+    | FileMonitorEventMovedIn+    | FileMonitorEventMovedOut+    | AnotherFileMonitorEvent Int+    deriving (Show, Eq)++instance Enum FileMonitorEvent where+    fromEnum FileMonitorEventChanged = 0+    fromEnum FileMonitorEventChangesDoneHint = 1+    fromEnum FileMonitorEventDeleted = 2+    fromEnum FileMonitorEventCreated = 3+    fromEnum FileMonitorEventAttributeChanged = 4+    fromEnum FileMonitorEventPreUnmount = 5+    fromEnum FileMonitorEventUnmounted = 6+    fromEnum FileMonitorEventMoved = 7+    fromEnum FileMonitorEventRenamed = 8+    fromEnum FileMonitorEventMovedIn = 9+    fromEnum FileMonitorEventMovedOut = 10+    fromEnum (AnotherFileMonitorEvent k) = k++    toEnum 0 = FileMonitorEventChanged+    toEnum 1 = FileMonitorEventChangesDoneHint+    toEnum 2 = FileMonitorEventDeleted+    toEnum 3 = FileMonitorEventCreated+    toEnum 4 = FileMonitorEventAttributeChanged+    toEnum 5 = FileMonitorEventPreUnmount+    toEnum 6 = FileMonitorEventUnmounted+    toEnum 7 = FileMonitorEventMoved+    toEnum 8 = FileMonitorEventRenamed+    toEnum 9 = FileMonitorEventMovedIn+    toEnum 10 = FileMonitorEventMovedOut+    toEnum k = AnotherFileMonitorEvent k++foreign import ccall "g_file_monitor_event_get_type" c_g_file_monitor_event_get_type :: +    IO GType++instance BoxedEnum FileMonitorEvent where+    boxedEnumType _ = c_g_file_monitor_event_get_type++-- Enum FileAttributeType++data FileAttributeType = +      FileAttributeTypeInvalid+    | FileAttributeTypeString+    | FileAttributeTypeByteString+    | FileAttributeTypeBoolean+    | FileAttributeTypeUint32+    | FileAttributeTypeInt32+    | FileAttributeTypeUint64+    | FileAttributeTypeInt64+    | FileAttributeTypeObject+    | FileAttributeTypeStringv+    | AnotherFileAttributeType Int+    deriving (Show, Eq)++instance Enum FileAttributeType where+    fromEnum FileAttributeTypeInvalid = 0+    fromEnum FileAttributeTypeString = 1+    fromEnum FileAttributeTypeByteString = 2+    fromEnum FileAttributeTypeBoolean = 3+    fromEnum FileAttributeTypeUint32 = 4+    fromEnum FileAttributeTypeInt32 = 5+    fromEnum FileAttributeTypeUint64 = 6+    fromEnum FileAttributeTypeInt64 = 7+    fromEnum FileAttributeTypeObject = 8+    fromEnum FileAttributeTypeStringv = 9+    fromEnum (AnotherFileAttributeType k) = k++    toEnum 0 = FileAttributeTypeInvalid+    toEnum 1 = FileAttributeTypeString+    toEnum 2 = FileAttributeTypeByteString+    toEnum 3 = FileAttributeTypeBoolean+    toEnum 4 = FileAttributeTypeUint32+    toEnum 5 = FileAttributeTypeInt32+    toEnum 6 = FileAttributeTypeUint64+    toEnum 7 = FileAttributeTypeInt64+    toEnum 8 = FileAttributeTypeObject+    toEnum 9 = FileAttributeTypeStringv+    toEnum k = AnotherFileAttributeType k++foreign import ccall "g_file_attribute_type_get_type" c_g_file_attribute_type_get_type :: +    IO GType++instance BoxedEnum FileAttributeType where+    boxedEnumType _ = c_g_file_attribute_type_get_type++-- Enum FileAttributeStatus++data FileAttributeStatus = +      FileAttributeStatusUnset+    | FileAttributeStatusSet+    | FileAttributeStatusErrorSetting+    | AnotherFileAttributeStatus Int+    deriving (Show, Eq)++instance Enum FileAttributeStatus where+    fromEnum FileAttributeStatusUnset = 0+    fromEnum FileAttributeStatusSet = 1+    fromEnum FileAttributeStatusErrorSetting = 2+    fromEnum (AnotherFileAttributeStatus k) = k++    toEnum 0 = FileAttributeStatusUnset+    toEnum 1 = FileAttributeStatusSet+    toEnum 2 = FileAttributeStatusErrorSetting+    toEnum k = AnotherFileAttributeStatus k++foreign import ccall "g_file_attribute_status_get_type" c_g_file_attribute_status_get_type :: +    IO GType++instance BoxedEnum FileAttributeStatus where+    boxedEnumType _ = c_g_file_attribute_status_get_type++-- Enum EmblemOrigin++data EmblemOrigin = +      EmblemOriginUnknown+    | EmblemOriginDevice+    | EmblemOriginLivemetadata+    | EmblemOriginTag+    | AnotherEmblemOrigin Int+    deriving (Show, Eq)++instance Enum EmblemOrigin where+    fromEnum EmblemOriginUnknown = 0+    fromEnum EmblemOriginDevice = 1+    fromEnum EmblemOriginLivemetadata = 2+    fromEnum EmblemOriginTag = 3+    fromEnum (AnotherEmblemOrigin k) = k++    toEnum 0 = EmblemOriginUnknown+    toEnum 1 = EmblemOriginDevice+    toEnum 2 = EmblemOriginLivemetadata+    toEnum 3 = EmblemOriginTag+    toEnum k = AnotherEmblemOrigin k++foreign import ccall "g_emblem_origin_get_type" c_g_emblem_origin_get_type :: +    IO GType++instance BoxedEnum EmblemOrigin where+    boxedEnumType _ = c_g_emblem_origin_get_type++-- Enum DriveStartStopType++data DriveStartStopType = +      DriveStartStopTypeUnknown+    | DriveStartStopTypeShutdown+    | DriveStartStopTypeNetwork+    | DriveStartStopTypeMultidisk+    | DriveStartStopTypePassword+    | AnotherDriveStartStopType Int+    deriving (Show, Eq)++instance Enum DriveStartStopType where+    fromEnum DriveStartStopTypeUnknown = 0+    fromEnum DriveStartStopTypeShutdown = 1+    fromEnum DriveStartStopTypeNetwork = 2+    fromEnum DriveStartStopTypeMultidisk = 3+    fromEnum DriveStartStopTypePassword = 4+    fromEnum (AnotherDriveStartStopType k) = k++    toEnum 0 = DriveStartStopTypeUnknown+    toEnum 1 = DriveStartStopTypeShutdown+    toEnum 2 = DriveStartStopTypeNetwork+    toEnum 3 = DriveStartStopTypeMultidisk+    toEnum 4 = DriveStartStopTypePassword+    toEnum k = AnotherDriveStartStopType k++foreign import ccall "g_drive_start_stop_type_get_type" c_g_drive_start_stop_type_get_type :: +    IO GType++instance BoxedEnum DriveStartStopType where+    boxedEnumType _ = c_g_drive_start_stop_type_get_type++-- Enum DataStreamNewlineType++data DataStreamNewlineType = +      DataStreamNewlineTypeLf+    | DataStreamNewlineTypeCr+    | DataStreamNewlineTypeCrLf+    | DataStreamNewlineTypeAny+    | AnotherDataStreamNewlineType Int+    deriving (Show, Eq)++instance Enum DataStreamNewlineType where+    fromEnum DataStreamNewlineTypeLf = 0+    fromEnum DataStreamNewlineTypeCr = 1+    fromEnum DataStreamNewlineTypeCrLf = 2+    fromEnum DataStreamNewlineTypeAny = 3+    fromEnum (AnotherDataStreamNewlineType k) = k++    toEnum 0 = DataStreamNewlineTypeLf+    toEnum 1 = DataStreamNewlineTypeCr+    toEnum 2 = DataStreamNewlineTypeCrLf+    toEnum 3 = DataStreamNewlineTypeAny+    toEnum k = AnotherDataStreamNewlineType k++foreign import ccall "g_data_stream_newline_type_get_type" c_g_data_stream_newline_type_get_type :: +    IO GType++instance BoxedEnum DataStreamNewlineType where+    boxedEnumType _ = c_g_data_stream_newline_type_get_type++-- Enum DataStreamByteOrder++data DataStreamByteOrder = +      DataStreamByteOrderBigEndian+    | DataStreamByteOrderLittleEndian+    | DataStreamByteOrderHostEndian+    | AnotherDataStreamByteOrder Int+    deriving (Show, Eq)++instance Enum DataStreamByteOrder where+    fromEnum DataStreamByteOrderBigEndian = 0+    fromEnum DataStreamByteOrderLittleEndian = 1+    fromEnum DataStreamByteOrderHostEndian = 2+    fromEnum (AnotherDataStreamByteOrder k) = k++    toEnum 0 = DataStreamByteOrderBigEndian+    toEnum 1 = DataStreamByteOrderLittleEndian+    toEnum 2 = DataStreamByteOrderHostEndian+    toEnum k = AnotherDataStreamByteOrder k++foreign import ccall "g_data_stream_byte_order_get_type" c_g_data_stream_byte_order_get_type :: +    IO GType++instance BoxedEnum DataStreamByteOrder where+    boxedEnumType _ = c_g_data_stream_byte_order_get_type++-- Enum DBusMessageType++data DBusMessageType = +      DBusMessageTypeInvalid+    | DBusMessageTypeMethodCall+    | DBusMessageTypeMethodReturn+    | DBusMessageTypeError+    | DBusMessageTypeSignal+    | AnotherDBusMessageType Int+    deriving (Show, Eq)++instance Enum DBusMessageType where+    fromEnum DBusMessageTypeInvalid = 0+    fromEnum DBusMessageTypeMethodCall = 1+    fromEnum DBusMessageTypeMethodReturn = 2+    fromEnum DBusMessageTypeError = 3+    fromEnum DBusMessageTypeSignal = 4+    fromEnum (AnotherDBusMessageType k) = k++    toEnum 0 = DBusMessageTypeInvalid+    toEnum 1 = DBusMessageTypeMethodCall+    toEnum 2 = DBusMessageTypeMethodReturn+    toEnum 3 = DBusMessageTypeError+    toEnum 4 = DBusMessageTypeSignal+    toEnum k = AnotherDBusMessageType k++foreign import ccall "g_dbus_message_type_get_type" c_g_dbus_message_type_get_type :: +    IO GType++instance BoxedEnum DBusMessageType where+    boxedEnumType _ = c_g_dbus_message_type_get_type++-- Enum DBusMessageHeaderField++data DBusMessageHeaderField = +      DBusMessageHeaderFieldInvalid+    | DBusMessageHeaderFieldPath+    | DBusMessageHeaderFieldInterface+    | DBusMessageHeaderFieldMember+    | DBusMessageHeaderFieldErrorName+    | DBusMessageHeaderFieldReplySerial+    | DBusMessageHeaderFieldDestination+    | DBusMessageHeaderFieldSender+    | DBusMessageHeaderFieldSignature+    | DBusMessageHeaderFieldNumUnixFds+    | AnotherDBusMessageHeaderField Int+    deriving (Show, Eq)++instance Enum DBusMessageHeaderField where+    fromEnum DBusMessageHeaderFieldInvalid = 0+    fromEnum DBusMessageHeaderFieldPath = 1+    fromEnum DBusMessageHeaderFieldInterface = 2+    fromEnum DBusMessageHeaderFieldMember = 3+    fromEnum DBusMessageHeaderFieldErrorName = 4+    fromEnum DBusMessageHeaderFieldReplySerial = 5+    fromEnum DBusMessageHeaderFieldDestination = 6+    fromEnum DBusMessageHeaderFieldSender = 7+    fromEnum DBusMessageHeaderFieldSignature = 8+    fromEnum DBusMessageHeaderFieldNumUnixFds = 9+    fromEnum (AnotherDBusMessageHeaderField k) = k++    toEnum 0 = DBusMessageHeaderFieldInvalid+    toEnum 1 = DBusMessageHeaderFieldPath+    toEnum 2 = DBusMessageHeaderFieldInterface+    toEnum 3 = DBusMessageHeaderFieldMember+    toEnum 4 = DBusMessageHeaderFieldErrorName+    toEnum 5 = DBusMessageHeaderFieldReplySerial+    toEnum 6 = DBusMessageHeaderFieldDestination+    toEnum 7 = DBusMessageHeaderFieldSender+    toEnum 8 = DBusMessageHeaderFieldSignature+    toEnum 9 = DBusMessageHeaderFieldNumUnixFds+    toEnum k = AnotherDBusMessageHeaderField k++foreign import ccall "g_dbus_message_header_field_get_type" c_g_dbus_message_header_field_get_type :: +    IO GType++instance BoxedEnum DBusMessageHeaderField where+    boxedEnumType _ = c_g_dbus_message_header_field_get_type++-- Enum DBusMessageByteOrder++data DBusMessageByteOrder = +      DBusMessageByteOrderBigEndian+    | DBusMessageByteOrderLittleEndian+    | AnotherDBusMessageByteOrder Int+    deriving (Show, Eq)++instance Enum DBusMessageByteOrder where+    fromEnum DBusMessageByteOrderBigEndian = 66+    fromEnum DBusMessageByteOrderLittleEndian = 108+    fromEnum (AnotherDBusMessageByteOrder k) = k++    toEnum 66 = DBusMessageByteOrderBigEndian+    toEnum 108 = DBusMessageByteOrderLittleEndian+    toEnum k = AnotherDBusMessageByteOrder k++foreign import ccall "g_dbus_message_byte_order_get_type" c_g_dbus_message_byte_order_get_type :: +    IO GType++instance BoxedEnum DBusMessageByteOrder where+    boxedEnumType _ = c_g_dbus_message_byte_order_get_type++-- Enum DBusError++data DBusError = +      DBusErrorFailed+    | DBusErrorNoMemory+    | DBusErrorServiceUnknown+    | DBusErrorNameHasNoOwner+    | DBusErrorNoReply+    | DBusErrorIoError+    | DBusErrorBadAddress+    | DBusErrorNotSupported+    | DBusErrorLimitsExceeded+    | DBusErrorAccessDenied+    | DBusErrorAuthFailed+    | DBusErrorNoServer+    | DBusErrorTimeout+    | DBusErrorNoNetwork+    | DBusErrorAddressInUse+    | DBusErrorDisconnected+    | DBusErrorInvalidArgs+    | DBusErrorFileNotFound+    | DBusErrorFileExists+    | DBusErrorUnknownMethod+    | DBusErrorTimedOut+    | DBusErrorMatchRuleNotFound+    | DBusErrorMatchRuleInvalid+    | DBusErrorSpawnExecFailed+    | DBusErrorSpawnForkFailed+    | DBusErrorSpawnChildExited+    | DBusErrorSpawnChildSignaled+    | DBusErrorSpawnFailed+    | DBusErrorSpawnSetupFailed+    | DBusErrorSpawnConfigInvalid+    | DBusErrorSpawnServiceInvalid+    | DBusErrorSpawnServiceNotFound+    | DBusErrorSpawnPermissionsInvalid+    | DBusErrorSpawnFileInvalid+    | DBusErrorSpawnNoMemory+    | DBusErrorUnixProcessIdUnknown+    | DBusErrorInvalidSignature+    | DBusErrorInvalidFileContent+    | DBusErrorSelinuxSecurityContextUnknown+    | DBusErrorAdtAuditDataUnknown+    | DBusErrorObjectPathInUse+    | DBusErrorUnknownObject+    | DBusErrorUnknownInterface+    | DBusErrorUnknownProperty+    | DBusErrorPropertyReadOnly+    | AnotherDBusError Int+    deriving (Show, Eq)++instance Enum DBusError where+    fromEnum DBusErrorFailed = 0+    fromEnum DBusErrorNoMemory = 1+    fromEnum DBusErrorServiceUnknown = 2+    fromEnum DBusErrorNameHasNoOwner = 3+    fromEnum DBusErrorNoReply = 4+    fromEnum DBusErrorIoError = 5+    fromEnum DBusErrorBadAddress = 6+    fromEnum DBusErrorNotSupported = 7+    fromEnum DBusErrorLimitsExceeded = 8+    fromEnum DBusErrorAccessDenied = 9+    fromEnum DBusErrorAuthFailed = 10+    fromEnum DBusErrorNoServer = 11+    fromEnum DBusErrorTimeout = 12+    fromEnum DBusErrorNoNetwork = 13+    fromEnum DBusErrorAddressInUse = 14+    fromEnum DBusErrorDisconnected = 15+    fromEnum DBusErrorInvalidArgs = 16+    fromEnum DBusErrorFileNotFound = 17+    fromEnum DBusErrorFileExists = 18+    fromEnum DBusErrorUnknownMethod = 19+    fromEnum DBusErrorTimedOut = 20+    fromEnum DBusErrorMatchRuleNotFound = 21+    fromEnum DBusErrorMatchRuleInvalid = 22+    fromEnum DBusErrorSpawnExecFailed = 23+    fromEnum DBusErrorSpawnForkFailed = 24+    fromEnum DBusErrorSpawnChildExited = 25+    fromEnum DBusErrorSpawnChildSignaled = 26+    fromEnum DBusErrorSpawnFailed = 27+    fromEnum DBusErrorSpawnSetupFailed = 28+    fromEnum DBusErrorSpawnConfigInvalid = 29+    fromEnum DBusErrorSpawnServiceInvalid = 30+    fromEnum DBusErrorSpawnServiceNotFound = 31+    fromEnum DBusErrorSpawnPermissionsInvalid = 32+    fromEnum DBusErrorSpawnFileInvalid = 33+    fromEnum DBusErrorSpawnNoMemory = 34+    fromEnum DBusErrorUnixProcessIdUnknown = 35+    fromEnum DBusErrorInvalidSignature = 36+    fromEnum DBusErrorInvalidFileContent = 37+    fromEnum DBusErrorSelinuxSecurityContextUnknown = 38+    fromEnum DBusErrorAdtAuditDataUnknown = 39+    fromEnum DBusErrorObjectPathInUse = 40+    fromEnum DBusErrorUnknownObject = 41+    fromEnum DBusErrorUnknownInterface = 42+    fromEnum DBusErrorUnknownProperty = 43+    fromEnum DBusErrorPropertyReadOnly = 44+    fromEnum (AnotherDBusError k) = k++    toEnum 0 = DBusErrorFailed+    toEnum 1 = DBusErrorNoMemory+    toEnum 2 = DBusErrorServiceUnknown+    toEnum 3 = DBusErrorNameHasNoOwner+    toEnum 4 = DBusErrorNoReply+    toEnum 5 = DBusErrorIoError+    toEnum 6 = DBusErrorBadAddress+    toEnum 7 = DBusErrorNotSupported+    toEnum 8 = DBusErrorLimitsExceeded+    toEnum 9 = DBusErrorAccessDenied+    toEnum 10 = DBusErrorAuthFailed+    toEnum 11 = DBusErrorNoServer+    toEnum 12 = DBusErrorTimeout+    toEnum 13 = DBusErrorNoNetwork+    toEnum 14 = DBusErrorAddressInUse+    toEnum 15 = DBusErrorDisconnected+    toEnum 16 = DBusErrorInvalidArgs+    toEnum 17 = DBusErrorFileNotFound+    toEnum 18 = DBusErrorFileExists+    toEnum 19 = DBusErrorUnknownMethod+    toEnum 20 = DBusErrorTimedOut+    toEnum 21 = DBusErrorMatchRuleNotFound+    toEnum 22 = DBusErrorMatchRuleInvalid+    toEnum 23 = DBusErrorSpawnExecFailed+    toEnum 24 = DBusErrorSpawnForkFailed+    toEnum 25 = DBusErrorSpawnChildExited+    toEnum 26 = DBusErrorSpawnChildSignaled+    toEnum 27 = DBusErrorSpawnFailed+    toEnum 28 = DBusErrorSpawnSetupFailed+    toEnum 29 = DBusErrorSpawnConfigInvalid+    toEnum 30 = DBusErrorSpawnServiceInvalid+    toEnum 31 = DBusErrorSpawnServiceNotFound+    toEnum 32 = DBusErrorSpawnPermissionsInvalid+    toEnum 33 = DBusErrorSpawnFileInvalid+    toEnum 34 = DBusErrorSpawnNoMemory+    toEnum 35 = DBusErrorUnixProcessIdUnknown+    toEnum 36 = DBusErrorInvalidSignature+    toEnum 37 = DBusErrorInvalidFileContent+    toEnum 38 = DBusErrorSelinuxSecurityContextUnknown+    toEnum 39 = DBusErrorAdtAuditDataUnknown+    toEnum 40 = DBusErrorObjectPathInUse+    toEnum 41 = DBusErrorUnknownObject+    toEnum 42 = DBusErrorUnknownInterface+    toEnum 43 = DBusErrorUnknownProperty+    toEnum 44 = DBusErrorPropertyReadOnly+    toEnum k = AnotherDBusError k++instance GErrorClass DBusError where+    gerrorClassDomain _ = "g-dbus-error-quark"++catchDBusError ::+    IO a ->+    (DBusError -> GErrorMessage -> IO a) ->+    IO a+catchDBusError = catchGErrorJustDomain++handleDBusError ::+    (DBusError -> GErrorMessage -> IO a) ->+    IO a ->+    IO a+handleDBusError = handleGErrorJustDomain++foreign import ccall "g_dbus_error_get_type" c_g_dbus_error_get_type :: +    IO GType++instance BoxedEnum DBusError where+    boxedEnumType _ = c_g_dbus_error_get_type++-- Enum CredentialsType++data CredentialsType = +      CredentialsTypeInvalid+    | CredentialsTypeLinuxUcred+    | CredentialsTypeFreebsdCmsgcred+    | CredentialsTypeOpenbsdSockpeercred+    | CredentialsTypeSolarisUcred+    | CredentialsTypeNetbsdUnpcbid+    | AnotherCredentialsType Int+    deriving (Show, Eq)++instance Enum CredentialsType where+    fromEnum CredentialsTypeInvalid = 0+    fromEnum CredentialsTypeLinuxUcred = 1+    fromEnum CredentialsTypeFreebsdCmsgcred = 2+    fromEnum CredentialsTypeOpenbsdSockpeercred = 3+    fromEnum CredentialsTypeSolarisUcred = 4+    fromEnum CredentialsTypeNetbsdUnpcbid = 5+    fromEnum (AnotherCredentialsType k) = k++    toEnum 0 = CredentialsTypeInvalid+    toEnum 1 = CredentialsTypeLinuxUcred+    toEnum 2 = CredentialsTypeFreebsdCmsgcred+    toEnum 3 = CredentialsTypeOpenbsdSockpeercred+    toEnum 4 = CredentialsTypeSolarisUcred+    toEnum 5 = CredentialsTypeNetbsdUnpcbid+    toEnum k = AnotherCredentialsType k++foreign import ccall "g_credentials_type_get_type" c_g_credentials_type_get_type :: +    IO GType++instance BoxedEnum CredentialsType where+    boxedEnumType _ = c_g_credentials_type_get_type++-- Enum ConverterResult++data ConverterResult = +      ConverterResultError+    | ConverterResultConverted+    | ConverterResultFinished+    | ConverterResultFlushed+    | AnotherConverterResult Int+    deriving (Show, Eq)++instance Enum ConverterResult where+    fromEnum ConverterResultError = 0+    fromEnum ConverterResultConverted = 1+    fromEnum ConverterResultFinished = 2+    fromEnum ConverterResultFlushed = 3+    fromEnum (AnotherConverterResult k) = k++    toEnum 0 = ConverterResultError+    toEnum 1 = ConverterResultConverted+    toEnum 2 = ConverterResultFinished+    toEnum 3 = ConverterResultFlushed+    toEnum k = AnotherConverterResult k++foreign import ccall "g_converter_result_get_type" c_g_converter_result_get_type :: +    IO GType++instance BoxedEnum ConverterResult where+    boxedEnumType _ = c_g_converter_result_get_type++-- Enum BusType++data BusType = +      BusTypeStarter+    | BusTypeNone+    | BusTypeSystem+    | BusTypeSession+    | AnotherBusType Int+    deriving (Show, Eq)++instance Enum BusType where+    fromEnum BusTypeStarter = -1+    fromEnum BusTypeNone = 0+    fromEnum BusTypeSystem = 1+    fromEnum BusTypeSession = 2+    fromEnum (AnotherBusType k) = k++    toEnum -1 = BusTypeStarter+    toEnum 0 = BusTypeNone+    toEnum 1 = BusTypeSystem+    toEnum 2 = BusTypeSession+    toEnum k = AnotherBusType k++foreign import ccall "g_bus_type_get_type" c_g_bus_type_get_type :: +    IO GType++instance BoxedEnum BusType where+    boxedEnumType _ = c_g_bus_type_get_type++
+ GI/Gio/Flags.hs view
@@ -0,0 +1,1188 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Flags+    ( ++-- * Exported types+    TlsPasswordFlags(..)                    ,+    TlsDatabaseVerifyFlags(..)              ,+    TlsCertificateFlags(..)                 ,+    TestDBusFlags(..)                       ,+    SubprocessFlags(..)                     ,+    SocketMsgFlags(..)                      ,+    SettingsBindFlags(..)                   ,+    ResourceLookupFlags(..)                 ,+    ResourceFlags(..)                       ,+    OutputStreamSpliceFlags(..)             ,+    MountUnmountFlags(..)                   ,+    MountMountFlags(..)                     ,+    IOStreamSpliceFlags(..)                 ,+    FileQueryInfoFlags(..)                  ,+    FileMonitorFlags(..)                    ,+    FileMeasureFlags(..)                    ,+    FileCreateFlags(..)                     ,+    FileCopyFlags(..)                       ,+    FileAttributeInfoFlags(..)              ,+    DriveStartFlags(..)                     ,+    DBusSubtreeFlags(..)                    ,+    DBusSignalFlags(..)                     ,+    DBusServerFlags(..)                     ,+    DBusSendMessageFlags(..)                ,+    DBusProxyFlags(..)                      ,+    DBusPropertyInfoFlags(..)               ,+    DBusObjectManagerClientFlags(..)        ,+    DBusMessageFlags(..)                    ,+    DBusInterfaceSkeletonFlags(..)          ,+    DBusConnectionFlags(..)                 ,+    DBusCapabilityFlags(..)                 ,+    DBusCallFlags(..)                       ,+    ConverterFlags(..)                      ,+    BusNameWatcherFlags(..)                 ,+    BusNameOwnerFlags(..)                   ,+    AskPasswordFlags(..)                    ,+    ApplicationFlags(..)                    ,+    AppInfoCreateFlags(..)                  ,+++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+++++-- Flags TlsPasswordFlags++data TlsPasswordFlags = +      TlsPasswordFlagsNone+    | TlsPasswordFlagsRetry+    | TlsPasswordFlagsManyTries+    | TlsPasswordFlagsFinalTry+    | AnotherTlsPasswordFlags Int+    deriving (Show, Eq)++instance Enum TlsPasswordFlags where+    fromEnum TlsPasswordFlagsNone = 0+    fromEnum TlsPasswordFlagsRetry = 2+    fromEnum TlsPasswordFlagsManyTries = 4+    fromEnum TlsPasswordFlagsFinalTry = 8+    fromEnum (AnotherTlsPasswordFlags k) = k++    toEnum 0 = TlsPasswordFlagsNone+    toEnum 2 = TlsPasswordFlagsRetry+    toEnum 4 = TlsPasswordFlagsManyTries+    toEnum 8 = TlsPasswordFlagsFinalTry+    toEnum k = AnotherTlsPasswordFlags k++foreign import ccall "g_tls_password_flags_get_type" c_g_tls_password_flags_get_type :: +    IO GType++instance BoxedEnum TlsPasswordFlags where+    boxedEnumType _ = c_g_tls_password_flags_get_type++instance IsGFlag TlsPasswordFlags++-- Flags TlsDatabaseVerifyFlags++data TlsDatabaseVerifyFlags = +      TlsDatabaseVerifyFlagsNone+    | AnotherTlsDatabaseVerifyFlags Int+    deriving (Show, Eq)++instance Enum TlsDatabaseVerifyFlags where+    fromEnum TlsDatabaseVerifyFlagsNone = 0+    fromEnum (AnotherTlsDatabaseVerifyFlags k) = k++    toEnum 0 = TlsDatabaseVerifyFlagsNone+    toEnum k = AnotherTlsDatabaseVerifyFlags k++foreign import ccall "g_tls_database_verify_flags_get_type" c_g_tls_database_verify_flags_get_type :: +    IO GType++instance BoxedEnum TlsDatabaseVerifyFlags where+    boxedEnumType _ = c_g_tls_database_verify_flags_get_type++instance IsGFlag TlsDatabaseVerifyFlags++-- Flags TlsCertificateFlags++data TlsCertificateFlags = +      TlsCertificateFlagsUnknownCa+    | TlsCertificateFlagsBadIdentity+    | TlsCertificateFlagsNotActivated+    | TlsCertificateFlagsExpired+    | TlsCertificateFlagsRevoked+    | TlsCertificateFlagsInsecure+    | TlsCertificateFlagsGenericError+    | TlsCertificateFlagsValidateAll+    | AnotherTlsCertificateFlags Int+    deriving (Show, Eq)++instance Enum TlsCertificateFlags where+    fromEnum TlsCertificateFlagsUnknownCa = 1+    fromEnum TlsCertificateFlagsBadIdentity = 2+    fromEnum TlsCertificateFlagsNotActivated = 4+    fromEnum TlsCertificateFlagsExpired = 8+    fromEnum TlsCertificateFlagsRevoked = 16+    fromEnum TlsCertificateFlagsInsecure = 32+    fromEnum TlsCertificateFlagsGenericError = 64+    fromEnum TlsCertificateFlagsValidateAll = 127+    fromEnum (AnotherTlsCertificateFlags k) = k++    toEnum 1 = TlsCertificateFlagsUnknownCa+    toEnum 2 = TlsCertificateFlagsBadIdentity+    toEnum 4 = TlsCertificateFlagsNotActivated+    toEnum 8 = TlsCertificateFlagsExpired+    toEnum 16 = TlsCertificateFlagsRevoked+    toEnum 32 = TlsCertificateFlagsInsecure+    toEnum 64 = TlsCertificateFlagsGenericError+    toEnum 127 = TlsCertificateFlagsValidateAll+    toEnum k = AnotherTlsCertificateFlags k++foreign import ccall "g_tls_certificate_flags_get_type" c_g_tls_certificate_flags_get_type :: +    IO GType++instance BoxedEnum TlsCertificateFlags where+    boxedEnumType _ = c_g_tls_certificate_flags_get_type++instance IsGFlag TlsCertificateFlags++-- Flags TestDBusFlags++data TestDBusFlags = +      TestDBusFlagsNone+    | AnotherTestDBusFlags Int+    deriving (Show, Eq)++instance Enum TestDBusFlags where+    fromEnum TestDBusFlagsNone = 0+    fromEnum (AnotherTestDBusFlags k) = k++    toEnum 0 = TestDBusFlagsNone+    toEnum k = AnotherTestDBusFlags k++foreign import ccall "g_test_dbus_flags_get_type" c_g_test_dbus_flags_get_type :: +    IO GType++instance BoxedEnum TestDBusFlags where+    boxedEnumType _ = c_g_test_dbus_flags_get_type++instance IsGFlag TestDBusFlags++-- Flags SubprocessFlags++data SubprocessFlags = +      SubprocessFlagsNone+    | SubprocessFlagsStdinPipe+    | SubprocessFlagsStdinInherit+    | SubprocessFlagsStdoutPipe+    | SubprocessFlagsStdoutSilence+    | SubprocessFlagsStderrPipe+    | SubprocessFlagsStderrSilence+    | SubprocessFlagsStderrMerge+    | SubprocessFlagsInheritFds+    | AnotherSubprocessFlags Int+    deriving (Show, Eq)++instance Enum SubprocessFlags where+    fromEnum SubprocessFlagsNone = 0+    fromEnum SubprocessFlagsStdinPipe = 1+    fromEnum SubprocessFlagsStdinInherit = 2+    fromEnum SubprocessFlagsStdoutPipe = 4+    fromEnum SubprocessFlagsStdoutSilence = 8+    fromEnum SubprocessFlagsStderrPipe = 16+    fromEnum SubprocessFlagsStderrSilence = 32+    fromEnum SubprocessFlagsStderrMerge = 64+    fromEnum SubprocessFlagsInheritFds = 128+    fromEnum (AnotherSubprocessFlags k) = k++    toEnum 0 = SubprocessFlagsNone+    toEnum 1 = SubprocessFlagsStdinPipe+    toEnum 2 = SubprocessFlagsStdinInherit+    toEnum 4 = SubprocessFlagsStdoutPipe+    toEnum 8 = SubprocessFlagsStdoutSilence+    toEnum 16 = SubprocessFlagsStderrPipe+    toEnum 32 = SubprocessFlagsStderrSilence+    toEnum 64 = SubprocessFlagsStderrMerge+    toEnum 128 = SubprocessFlagsInheritFds+    toEnum k = AnotherSubprocessFlags k++foreign import ccall "g_subprocess_flags_get_type" c_g_subprocess_flags_get_type :: +    IO GType++instance BoxedEnum SubprocessFlags where+    boxedEnumType _ = c_g_subprocess_flags_get_type++instance IsGFlag SubprocessFlags++-- Flags SocketMsgFlags++data SocketMsgFlags = +      SocketMsgFlagsNone+    | SocketMsgFlagsOob+    | SocketMsgFlagsPeek+    | SocketMsgFlagsDontroute+    | AnotherSocketMsgFlags Int+    deriving (Show, Eq)++instance Enum SocketMsgFlags where+    fromEnum SocketMsgFlagsNone = 0+    fromEnum SocketMsgFlagsOob = 1+    fromEnum SocketMsgFlagsPeek = 2+    fromEnum SocketMsgFlagsDontroute = 4+    fromEnum (AnotherSocketMsgFlags k) = k++    toEnum 0 = SocketMsgFlagsNone+    toEnum 1 = SocketMsgFlagsOob+    toEnum 2 = SocketMsgFlagsPeek+    toEnum 4 = SocketMsgFlagsDontroute+    toEnum k = AnotherSocketMsgFlags k++foreign import ccall "g_socket_msg_flags_get_type" c_g_socket_msg_flags_get_type :: +    IO GType++instance BoxedEnum SocketMsgFlags where+    boxedEnumType _ = c_g_socket_msg_flags_get_type++instance IsGFlag SocketMsgFlags++-- Flags SettingsBindFlags++data SettingsBindFlags = +      SettingsBindFlagsDefault+    | SettingsBindFlagsGet+    | SettingsBindFlagsSet+    | SettingsBindFlagsNoSensitivity+    | SettingsBindFlagsGetNoChanges+    | SettingsBindFlagsInvertBoolean+    | AnotherSettingsBindFlags Int+    deriving (Show, Eq)++instance Enum SettingsBindFlags where+    fromEnum SettingsBindFlagsDefault = 0+    fromEnum SettingsBindFlagsGet = 1+    fromEnum SettingsBindFlagsSet = 2+    fromEnum SettingsBindFlagsNoSensitivity = 4+    fromEnum SettingsBindFlagsGetNoChanges = 8+    fromEnum SettingsBindFlagsInvertBoolean = 16+    fromEnum (AnotherSettingsBindFlags k) = k++    toEnum 0 = SettingsBindFlagsDefault+    toEnum 1 = SettingsBindFlagsGet+    toEnum 2 = SettingsBindFlagsSet+    toEnum 4 = SettingsBindFlagsNoSensitivity+    toEnum 8 = SettingsBindFlagsGetNoChanges+    toEnum 16 = SettingsBindFlagsInvertBoolean+    toEnum k = AnotherSettingsBindFlags k++foreign import ccall "g_settings_bind_flags_get_type" c_g_settings_bind_flags_get_type :: +    IO GType++instance BoxedEnum SettingsBindFlags where+    boxedEnumType _ = c_g_settings_bind_flags_get_type++instance IsGFlag SettingsBindFlags++-- Flags ResourceLookupFlags++data ResourceLookupFlags = +      ResourceLookupFlagsNone+    | AnotherResourceLookupFlags Int+    deriving (Show, Eq)++instance Enum ResourceLookupFlags where+    fromEnum ResourceLookupFlagsNone = 0+    fromEnum (AnotherResourceLookupFlags k) = k++    toEnum 0 = ResourceLookupFlagsNone+    toEnum k = AnotherResourceLookupFlags k++foreign import ccall "g_resource_lookup_flags_get_type" c_g_resource_lookup_flags_get_type :: +    IO GType++instance BoxedEnum ResourceLookupFlags where+    boxedEnumType _ = c_g_resource_lookup_flags_get_type++instance IsGFlag ResourceLookupFlags++-- Flags ResourceFlags++data ResourceFlags = +      ResourceFlagsNone+    | ResourceFlagsCompressed+    | AnotherResourceFlags Int+    deriving (Show, Eq)++instance Enum ResourceFlags where+    fromEnum ResourceFlagsNone = 0+    fromEnum ResourceFlagsCompressed = 1+    fromEnum (AnotherResourceFlags k) = k++    toEnum 0 = ResourceFlagsNone+    toEnum 1 = ResourceFlagsCompressed+    toEnum k = AnotherResourceFlags k++foreign import ccall "g_resource_flags_get_type" c_g_resource_flags_get_type :: +    IO GType++instance BoxedEnum ResourceFlags where+    boxedEnumType _ = c_g_resource_flags_get_type++instance IsGFlag ResourceFlags++-- Flags OutputStreamSpliceFlags++data OutputStreamSpliceFlags = +      OutputStreamSpliceFlagsNone+    | OutputStreamSpliceFlagsCloseSource+    | OutputStreamSpliceFlagsCloseTarget+    | AnotherOutputStreamSpliceFlags Int+    deriving (Show, Eq)++instance Enum OutputStreamSpliceFlags where+    fromEnum OutputStreamSpliceFlagsNone = 0+    fromEnum OutputStreamSpliceFlagsCloseSource = 1+    fromEnum OutputStreamSpliceFlagsCloseTarget = 2+    fromEnum (AnotherOutputStreamSpliceFlags k) = k++    toEnum 0 = OutputStreamSpliceFlagsNone+    toEnum 1 = OutputStreamSpliceFlagsCloseSource+    toEnum 2 = OutputStreamSpliceFlagsCloseTarget+    toEnum k = AnotherOutputStreamSpliceFlags k++foreign import ccall "g_output_stream_splice_flags_get_type" c_g_output_stream_splice_flags_get_type :: +    IO GType++instance BoxedEnum OutputStreamSpliceFlags where+    boxedEnumType _ = c_g_output_stream_splice_flags_get_type++instance IsGFlag OutputStreamSpliceFlags++-- Flags MountUnmountFlags++data MountUnmountFlags = +      MountUnmountFlagsNone+    | MountUnmountFlagsForce+    | AnotherMountUnmountFlags Int+    deriving (Show, Eq)++instance Enum MountUnmountFlags where+    fromEnum MountUnmountFlagsNone = 0+    fromEnum MountUnmountFlagsForce = 1+    fromEnum (AnotherMountUnmountFlags k) = k++    toEnum 0 = MountUnmountFlagsNone+    toEnum 1 = MountUnmountFlagsForce+    toEnum k = AnotherMountUnmountFlags k++foreign import ccall "g_mount_unmount_flags_get_type" c_g_mount_unmount_flags_get_type :: +    IO GType++instance BoxedEnum MountUnmountFlags where+    boxedEnumType _ = c_g_mount_unmount_flags_get_type++instance IsGFlag MountUnmountFlags++-- Flags MountMountFlags++data MountMountFlags = +      MountMountFlagsNone+    | AnotherMountMountFlags Int+    deriving (Show, Eq)++instance Enum MountMountFlags where+    fromEnum MountMountFlagsNone = 0+    fromEnum (AnotherMountMountFlags k) = k++    toEnum 0 = MountMountFlagsNone+    toEnum k = AnotherMountMountFlags k++foreign import ccall "g_mount_mount_flags_get_type" c_g_mount_mount_flags_get_type :: +    IO GType++instance BoxedEnum MountMountFlags where+    boxedEnumType _ = c_g_mount_mount_flags_get_type++instance IsGFlag MountMountFlags++-- Flags IOStreamSpliceFlags++data IOStreamSpliceFlags = +      IOStreamSpliceFlagsNone+    | IOStreamSpliceFlagsCloseStream1+    | IOStreamSpliceFlagsCloseStream2+    | IOStreamSpliceFlagsWaitForBoth+    | AnotherIOStreamSpliceFlags Int+    deriving (Show, Eq)++instance Enum IOStreamSpliceFlags where+    fromEnum IOStreamSpliceFlagsNone = 0+    fromEnum IOStreamSpliceFlagsCloseStream1 = 1+    fromEnum IOStreamSpliceFlagsCloseStream2 = 2+    fromEnum IOStreamSpliceFlagsWaitForBoth = 4+    fromEnum (AnotherIOStreamSpliceFlags k) = k++    toEnum 0 = IOStreamSpliceFlagsNone+    toEnum 1 = IOStreamSpliceFlagsCloseStream1+    toEnum 2 = IOStreamSpliceFlagsCloseStream2+    toEnum 4 = IOStreamSpliceFlagsWaitForBoth+    toEnum k = AnotherIOStreamSpliceFlags k++foreign import ccall "g_io_stream_splice_flags_get_type" c_g_io_stream_splice_flags_get_type :: +    IO GType++instance BoxedEnum IOStreamSpliceFlags where+    boxedEnumType _ = c_g_io_stream_splice_flags_get_type++instance IsGFlag IOStreamSpliceFlags++-- Flags FileQueryInfoFlags++data FileQueryInfoFlags = +      FileQueryInfoFlagsNone+    | FileQueryInfoFlagsNofollowSymlinks+    | AnotherFileQueryInfoFlags Int+    deriving (Show, Eq)++instance Enum FileQueryInfoFlags where+    fromEnum FileQueryInfoFlagsNone = 0+    fromEnum FileQueryInfoFlagsNofollowSymlinks = 1+    fromEnum (AnotherFileQueryInfoFlags k) = k++    toEnum 0 = FileQueryInfoFlagsNone+    toEnum 1 = FileQueryInfoFlagsNofollowSymlinks+    toEnum k = AnotherFileQueryInfoFlags k++foreign import ccall "g_file_query_info_flags_get_type" c_g_file_query_info_flags_get_type :: +    IO GType++instance BoxedEnum FileQueryInfoFlags where+    boxedEnumType _ = c_g_file_query_info_flags_get_type++instance IsGFlag FileQueryInfoFlags++-- Flags FileMonitorFlags++data FileMonitorFlags = +      FileMonitorFlagsNone+    | FileMonitorFlagsWatchMounts+    | FileMonitorFlagsSendMoved+    | FileMonitorFlagsWatchHardLinks+    | FileMonitorFlagsWatchMoves+    | AnotherFileMonitorFlags Int+    deriving (Show, Eq)++instance Enum FileMonitorFlags where+    fromEnum FileMonitorFlagsNone = 0+    fromEnum FileMonitorFlagsWatchMounts = 1+    fromEnum FileMonitorFlagsSendMoved = 2+    fromEnum FileMonitorFlagsWatchHardLinks = 4+    fromEnum FileMonitorFlagsWatchMoves = 8+    fromEnum (AnotherFileMonitorFlags k) = k++    toEnum 0 = FileMonitorFlagsNone+    toEnum 1 = FileMonitorFlagsWatchMounts+    toEnum 2 = FileMonitorFlagsSendMoved+    toEnum 4 = FileMonitorFlagsWatchHardLinks+    toEnum 8 = FileMonitorFlagsWatchMoves+    toEnum k = AnotherFileMonitorFlags k++foreign import ccall "g_file_monitor_flags_get_type" c_g_file_monitor_flags_get_type :: +    IO GType++instance BoxedEnum FileMonitorFlags where+    boxedEnumType _ = c_g_file_monitor_flags_get_type++instance IsGFlag FileMonitorFlags++-- Flags FileMeasureFlags++data FileMeasureFlags = +      FileMeasureFlagsNone+    | FileMeasureFlagsReportAnyError+    | FileMeasureFlagsApparentSize+    | FileMeasureFlagsNoXdev+    | AnotherFileMeasureFlags Int+    deriving (Show, Eq)++instance Enum FileMeasureFlags where+    fromEnum FileMeasureFlagsNone = 0+    fromEnum FileMeasureFlagsReportAnyError = 2+    fromEnum FileMeasureFlagsApparentSize = 4+    fromEnum FileMeasureFlagsNoXdev = 8+    fromEnum (AnotherFileMeasureFlags k) = k++    toEnum 0 = FileMeasureFlagsNone+    toEnum 2 = FileMeasureFlagsReportAnyError+    toEnum 4 = FileMeasureFlagsApparentSize+    toEnum 8 = FileMeasureFlagsNoXdev+    toEnum k = AnotherFileMeasureFlags k++foreign import ccall "g_file_measure_flags_get_type" c_g_file_measure_flags_get_type :: +    IO GType++instance BoxedEnum FileMeasureFlags where+    boxedEnumType _ = c_g_file_measure_flags_get_type++instance IsGFlag FileMeasureFlags++-- Flags FileCreateFlags++data FileCreateFlags = +      FileCreateFlagsNone+    | FileCreateFlagsPrivate+    | FileCreateFlagsReplaceDestination+    | AnotherFileCreateFlags Int+    deriving (Show, Eq)++instance Enum FileCreateFlags where+    fromEnum FileCreateFlagsNone = 0+    fromEnum FileCreateFlagsPrivate = 1+    fromEnum FileCreateFlagsReplaceDestination = 2+    fromEnum (AnotherFileCreateFlags k) = k++    toEnum 0 = FileCreateFlagsNone+    toEnum 1 = FileCreateFlagsPrivate+    toEnum 2 = FileCreateFlagsReplaceDestination+    toEnum k = AnotherFileCreateFlags k++foreign import ccall "g_file_create_flags_get_type" c_g_file_create_flags_get_type :: +    IO GType++instance BoxedEnum FileCreateFlags where+    boxedEnumType _ = c_g_file_create_flags_get_type++instance IsGFlag FileCreateFlags++-- Flags FileCopyFlags++data FileCopyFlags = +      FileCopyFlagsNone+    | FileCopyFlagsOverwrite+    | FileCopyFlagsBackup+    | FileCopyFlagsNofollowSymlinks+    | FileCopyFlagsAllMetadata+    | FileCopyFlagsNoFallbackForMove+    | FileCopyFlagsTargetDefaultPerms+    | AnotherFileCopyFlags Int+    deriving (Show, Eq)++instance Enum FileCopyFlags where+    fromEnum FileCopyFlagsNone = 0+    fromEnum FileCopyFlagsOverwrite = 1+    fromEnum FileCopyFlagsBackup = 2+    fromEnum FileCopyFlagsNofollowSymlinks = 4+    fromEnum FileCopyFlagsAllMetadata = 8+    fromEnum FileCopyFlagsNoFallbackForMove = 16+    fromEnum FileCopyFlagsTargetDefaultPerms = 32+    fromEnum (AnotherFileCopyFlags k) = k++    toEnum 0 = FileCopyFlagsNone+    toEnum 1 = FileCopyFlagsOverwrite+    toEnum 2 = FileCopyFlagsBackup+    toEnum 4 = FileCopyFlagsNofollowSymlinks+    toEnum 8 = FileCopyFlagsAllMetadata+    toEnum 16 = FileCopyFlagsNoFallbackForMove+    toEnum 32 = FileCopyFlagsTargetDefaultPerms+    toEnum k = AnotherFileCopyFlags k++foreign import ccall "g_file_copy_flags_get_type" c_g_file_copy_flags_get_type :: +    IO GType++instance BoxedEnum FileCopyFlags where+    boxedEnumType _ = c_g_file_copy_flags_get_type++instance IsGFlag FileCopyFlags++-- Flags FileAttributeInfoFlags++data FileAttributeInfoFlags = +      FileAttributeInfoFlagsNone+    | FileAttributeInfoFlagsCopyWithFile+    | FileAttributeInfoFlagsCopyWhenMoved+    | AnotherFileAttributeInfoFlags Int+    deriving (Show, Eq)++instance Enum FileAttributeInfoFlags where+    fromEnum FileAttributeInfoFlagsNone = 0+    fromEnum FileAttributeInfoFlagsCopyWithFile = 1+    fromEnum FileAttributeInfoFlagsCopyWhenMoved = 2+    fromEnum (AnotherFileAttributeInfoFlags k) = k++    toEnum 0 = FileAttributeInfoFlagsNone+    toEnum 1 = FileAttributeInfoFlagsCopyWithFile+    toEnum 2 = FileAttributeInfoFlagsCopyWhenMoved+    toEnum k = AnotherFileAttributeInfoFlags k++foreign import ccall "g_file_attribute_info_flags_get_type" c_g_file_attribute_info_flags_get_type :: +    IO GType++instance BoxedEnum FileAttributeInfoFlags where+    boxedEnumType _ = c_g_file_attribute_info_flags_get_type++instance IsGFlag FileAttributeInfoFlags++-- Flags DriveStartFlags++data DriveStartFlags = +      DriveStartFlagsNone+    | AnotherDriveStartFlags Int+    deriving (Show, Eq)++instance Enum DriveStartFlags where+    fromEnum DriveStartFlagsNone = 0+    fromEnum (AnotherDriveStartFlags k) = k++    toEnum 0 = DriveStartFlagsNone+    toEnum k = AnotherDriveStartFlags k++foreign import ccall "g_drive_start_flags_get_type" c_g_drive_start_flags_get_type :: +    IO GType++instance BoxedEnum DriveStartFlags where+    boxedEnumType _ = c_g_drive_start_flags_get_type++instance IsGFlag DriveStartFlags++-- Flags DBusSubtreeFlags++data DBusSubtreeFlags = +      DBusSubtreeFlagsNone+    | DBusSubtreeFlagsDispatchToUnenumeratedNodes+    | AnotherDBusSubtreeFlags Int+    deriving (Show, Eq)++instance Enum DBusSubtreeFlags where+    fromEnum DBusSubtreeFlagsNone = 0+    fromEnum DBusSubtreeFlagsDispatchToUnenumeratedNodes = 1+    fromEnum (AnotherDBusSubtreeFlags k) = k++    toEnum 0 = DBusSubtreeFlagsNone+    toEnum 1 = DBusSubtreeFlagsDispatchToUnenumeratedNodes+    toEnum k = AnotherDBusSubtreeFlags k++foreign import ccall "g_dbus_subtree_flags_get_type" c_g_dbus_subtree_flags_get_type :: +    IO GType++instance BoxedEnum DBusSubtreeFlags where+    boxedEnumType _ = c_g_dbus_subtree_flags_get_type++instance IsGFlag DBusSubtreeFlags++-- Flags DBusSignalFlags++data DBusSignalFlags = +      DBusSignalFlagsNone+    | DBusSignalFlagsNoMatchRule+    | DBusSignalFlagsMatchArg0Namespace+    | DBusSignalFlagsMatchArg0Path+    | AnotherDBusSignalFlags Int+    deriving (Show, Eq)++instance Enum DBusSignalFlags where+    fromEnum DBusSignalFlagsNone = 0+    fromEnum DBusSignalFlagsNoMatchRule = 1+    fromEnum DBusSignalFlagsMatchArg0Namespace = 2+    fromEnum DBusSignalFlagsMatchArg0Path = 4+    fromEnum (AnotherDBusSignalFlags k) = k++    toEnum 0 = DBusSignalFlagsNone+    toEnum 1 = DBusSignalFlagsNoMatchRule+    toEnum 2 = DBusSignalFlagsMatchArg0Namespace+    toEnum 4 = DBusSignalFlagsMatchArg0Path+    toEnum k = AnotherDBusSignalFlags k++foreign import ccall "g_dbus_signal_flags_get_type" c_g_dbus_signal_flags_get_type :: +    IO GType++instance BoxedEnum DBusSignalFlags where+    boxedEnumType _ = c_g_dbus_signal_flags_get_type++instance IsGFlag DBusSignalFlags++-- Flags DBusServerFlags++data DBusServerFlags = +      DBusServerFlagsNone+    | DBusServerFlagsRunInThread+    | DBusServerFlagsAuthenticationAllowAnonymous+    | AnotherDBusServerFlags Int+    deriving (Show, Eq)++instance Enum DBusServerFlags where+    fromEnum DBusServerFlagsNone = 0+    fromEnum DBusServerFlagsRunInThread = 1+    fromEnum DBusServerFlagsAuthenticationAllowAnonymous = 2+    fromEnum (AnotherDBusServerFlags k) = k++    toEnum 0 = DBusServerFlagsNone+    toEnum 1 = DBusServerFlagsRunInThread+    toEnum 2 = DBusServerFlagsAuthenticationAllowAnonymous+    toEnum k = AnotherDBusServerFlags k++foreign import ccall "g_dbus_server_flags_get_type" c_g_dbus_server_flags_get_type :: +    IO GType++instance BoxedEnum DBusServerFlags where+    boxedEnumType _ = c_g_dbus_server_flags_get_type++instance IsGFlag DBusServerFlags++-- Flags DBusSendMessageFlags++data DBusSendMessageFlags = +      DBusSendMessageFlagsNone+    | DBusSendMessageFlagsPreserveSerial+    | AnotherDBusSendMessageFlags Int+    deriving (Show, Eq)++instance Enum DBusSendMessageFlags where+    fromEnum DBusSendMessageFlagsNone = 0+    fromEnum DBusSendMessageFlagsPreserveSerial = 1+    fromEnum (AnotherDBusSendMessageFlags k) = k++    toEnum 0 = DBusSendMessageFlagsNone+    toEnum 1 = DBusSendMessageFlagsPreserveSerial+    toEnum k = AnotherDBusSendMessageFlags k++foreign import ccall "g_dbus_send_message_flags_get_type" c_g_dbus_send_message_flags_get_type :: +    IO GType++instance BoxedEnum DBusSendMessageFlags where+    boxedEnumType _ = c_g_dbus_send_message_flags_get_type++instance IsGFlag DBusSendMessageFlags++-- Flags DBusProxyFlags++data DBusProxyFlags = +      DBusProxyFlagsNone+    | DBusProxyFlagsDoNotLoadProperties+    | DBusProxyFlagsDoNotConnectSignals+    | DBusProxyFlagsDoNotAutoStart+    | DBusProxyFlagsGetInvalidatedProperties+    | DBusProxyFlagsDoNotAutoStartAtConstruction+    | AnotherDBusProxyFlags Int+    deriving (Show, Eq)++instance Enum DBusProxyFlags where+    fromEnum DBusProxyFlagsNone = 0+    fromEnum DBusProxyFlagsDoNotLoadProperties = 1+    fromEnum DBusProxyFlagsDoNotConnectSignals = 2+    fromEnum DBusProxyFlagsDoNotAutoStart = 4+    fromEnum DBusProxyFlagsGetInvalidatedProperties = 8+    fromEnum DBusProxyFlagsDoNotAutoStartAtConstruction = 16+    fromEnum (AnotherDBusProxyFlags k) = k++    toEnum 0 = DBusProxyFlagsNone+    toEnum 1 = DBusProxyFlagsDoNotLoadProperties+    toEnum 2 = DBusProxyFlagsDoNotConnectSignals+    toEnum 4 = DBusProxyFlagsDoNotAutoStart+    toEnum 8 = DBusProxyFlagsGetInvalidatedProperties+    toEnum 16 = DBusProxyFlagsDoNotAutoStartAtConstruction+    toEnum k = AnotherDBusProxyFlags k++foreign import ccall "g_dbus_proxy_flags_get_type" c_g_dbus_proxy_flags_get_type :: +    IO GType++instance BoxedEnum DBusProxyFlags where+    boxedEnumType _ = c_g_dbus_proxy_flags_get_type++instance IsGFlag DBusProxyFlags++-- Flags DBusPropertyInfoFlags++data DBusPropertyInfoFlags = +      DBusPropertyInfoFlagsNone+    | DBusPropertyInfoFlagsReadable+    | DBusPropertyInfoFlagsWritable+    | AnotherDBusPropertyInfoFlags Int+    deriving (Show, Eq)++instance Enum DBusPropertyInfoFlags where+    fromEnum DBusPropertyInfoFlagsNone = 0+    fromEnum DBusPropertyInfoFlagsReadable = 1+    fromEnum DBusPropertyInfoFlagsWritable = 2+    fromEnum (AnotherDBusPropertyInfoFlags k) = k++    toEnum 0 = DBusPropertyInfoFlagsNone+    toEnum 1 = DBusPropertyInfoFlagsReadable+    toEnum 2 = DBusPropertyInfoFlagsWritable+    toEnum k = AnotherDBusPropertyInfoFlags k++foreign import ccall "g_dbus_property_info_flags_get_type" c_g_dbus_property_info_flags_get_type :: +    IO GType++instance BoxedEnum DBusPropertyInfoFlags where+    boxedEnumType _ = c_g_dbus_property_info_flags_get_type++instance IsGFlag DBusPropertyInfoFlags++-- Flags DBusObjectManagerClientFlags++data DBusObjectManagerClientFlags = +      DBusObjectManagerClientFlagsNone+    | DBusObjectManagerClientFlagsDoNotAutoStart+    | AnotherDBusObjectManagerClientFlags Int+    deriving (Show, Eq)++instance Enum DBusObjectManagerClientFlags where+    fromEnum DBusObjectManagerClientFlagsNone = 0+    fromEnum DBusObjectManagerClientFlagsDoNotAutoStart = 1+    fromEnum (AnotherDBusObjectManagerClientFlags k) = k++    toEnum 0 = DBusObjectManagerClientFlagsNone+    toEnum 1 = DBusObjectManagerClientFlagsDoNotAutoStart+    toEnum k = AnotherDBusObjectManagerClientFlags k++foreign import ccall "g_dbus_object_manager_client_flags_get_type" c_g_dbus_object_manager_client_flags_get_type :: +    IO GType++instance BoxedEnum DBusObjectManagerClientFlags where+    boxedEnumType _ = c_g_dbus_object_manager_client_flags_get_type++instance IsGFlag DBusObjectManagerClientFlags++-- Flags DBusMessageFlags++data DBusMessageFlags = +      DBusMessageFlagsNone+    | DBusMessageFlagsNoReplyExpected+    | DBusMessageFlagsNoAutoStart+    | DBusMessageFlagsAllowInteractiveAuthorization+    | AnotherDBusMessageFlags Int+    deriving (Show, Eq)++instance Enum DBusMessageFlags where+    fromEnum DBusMessageFlagsNone = 0+    fromEnum DBusMessageFlagsNoReplyExpected = 1+    fromEnum DBusMessageFlagsNoAutoStart = 2+    fromEnum DBusMessageFlagsAllowInteractiveAuthorization = 4+    fromEnum (AnotherDBusMessageFlags k) = k++    toEnum 0 = DBusMessageFlagsNone+    toEnum 1 = DBusMessageFlagsNoReplyExpected+    toEnum 2 = DBusMessageFlagsNoAutoStart+    toEnum 4 = DBusMessageFlagsAllowInteractiveAuthorization+    toEnum k = AnotherDBusMessageFlags k++foreign import ccall "g_dbus_message_flags_get_type" c_g_dbus_message_flags_get_type :: +    IO GType++instance BoxedEnum DBusMessageFlags where+    boxedEnumType _ = c_g_dbus_message_flags_get_type++instance IsGFlag DBusMessageFlags++-- Flags DBusInterfaceSkeletonFlags++data DBusInterfaceSkeletonFlags = +      DBusInterfaceSkeletonFlagsNone+    | DBusInterfaceSkeletonFlagsHandleMethodInvocationsInThread+    | AnotherDBusInterfaceSkeletonFlags Int+    deriving (Show, Eq)++instance Enum DBusInterfaceSkeletonFlags where+    fromEnum DBusInterfaceSkeletonFlagsNone = 0+    fromEnum DBusInterfaceSkeletonFlagsHandleMethodInvocationsInThread = 1+    fromEnum (AnotherDBusInterfaceSkeletonFlags k) = k++    toEnum 0 = DBusInterfaceSkeletonFlagsNone+    toEnum 1 = DBusInterfaceSkeletonFlagsHandleMethodInvocationsInThread+    toEnum k = AnotherDBusInterfaceSkeletonFlags k++foreign import ccall "g_dbus_interface_skeleton_flags_get_type" c_g_dbus_interface_skeleton_flags_get_type :: +    IO GType++instance BoxedEnum DBusInterfaceSkeletonFlags where+    boxedEnumType _ = c_g_dbus_interface_skeleton_flags_get_type++instance IsGFlag DBusInterfaceSkeletonFlags++-- Flags DBusConnectionFlags++data DBusConnectionFlags = +      DBusConnectionFlagsNone+    | DBusConnectionFlagsAuthenticationClient+    | DBusConnectionFlagsAuthenticationServer+    | DBusConnectionFlagsAuthenticationAllowAnonymous+    | DBusConnectionFlagsMessageBusConnection+    | DBusConnectionFlagsDelayMessageProcessing+    | AnotherDBusConnectionFlags Int+    deriving (Show, Eq)++instance Enum DBusConnectionFlags where+    fromEnum DBusConnectionFlagsNone = 0+    fromEnum DBusConnectionFlagsAuthenticationClient = 1+    fromEnum DBusConnectionFlagsAuthenticationServer = 2+    fromEnum DBusConnectionFlagsAuthenticationAllowAnonymous = 4+    fromEnum DBusConnectionFlagsMessageBusConnection = 8+    fromEnum DBusConnectionFlagsDelayMessageProcessing = 16+    fromEnum (AnotherDBusConnectionFlags k) = k++    toEnum 0 = DBusConnectionFlagsNone+    toEnum 1 = DBusConnectionFlagsAuthenticationClient+    toEnum 2 = DBusConnectionFlagsAuthenticationServer+    toEnum 4 = DBusConnectionFlagsAuthenticationAllowAnonymous+    toEnum 8 = DBusConnectionFlagsMessageBusConnection+    toEnum 16 = DBusConnectionFlagsDelayMessageProcessing+    toEnum k = AnotherDBusConnectionFlags k++foreign import ccall "g_dbus_connection_flags_get_type" c_g_dbus_connection_flags_get_type :: +    IO GType++instance BoxedEnum DBusConnectionFlags where+    boxedEnumType _ = c_g_dbus_connection_flags_get_type++instance IsGFlag DBusConnectionFlags++-- Flags DBusCapabilityFlags++data DBusCapabilityFlags = +      DBusCapabilityFlagsNone+    | DBusCapabilityFlagsUnixFdPassing+    | AnotherDBusCapabilityFlags Int+    deriving (Show, Eq)++instance Enum DBusCapabilityFlags where+    fromEnum DBusCapabilityFlagsNone = 0+    fromEnum DBusCapabilityFlagsUnixFdPassing = 1+    fromEnum (AnotherDBusCapabilityFlags k) = k++    toEnum 0 = DBusCapabilityFlagsNone+    toEnum 1 = DBusCapabilityFlagsUnixFdPassing+    toEnum k = AnotherDBusCapabilityFlags k++foreign import ccall "g_dbus_capability_flags_get_type" c_g_dbus_capability_flags_get_type :: +    IO GType++instance BoxedEnum DBusCapabilityFlags where+    boxedEnumType _ = c_g_dbus_capability_flags_get_type++instance IsGFlag DBusCapabilityFlags++-- Flags DBusCallFlags++data DBusCallFlags = +      DBusCallFlagsNone+    | DBusCallFlagsNoAutoStart+    | DBusCallFlagsAllowInteractiveAuthorization+    | AnotherDBusCallFlags Int+    deriving (Show, Eq)++instance Enum DBusCallFlags where+    fromEnum DBusCallFlagsNone = 0+    fromEnum DBusCallFlagsNoAutoStart = 1+    fromEnum DBusCallFlagsAllowInteractiveAuthorization = 2+    fromEnum (AnotherDBusCallFlags k) = k++    toEnum 0 = DBusCallFlagsNone+    toEnum 1 = DBusCallFlagsNoAutoStart+    toEnum 2 = DBusCallFlagsAllowInteractiveAuthorization+    toEnum k = AnotherDBusCallFlags k++foreign import ccall "g_dbus_call_flags_get_type" c_g_dbus_call_flags_get_type :: +    IO GType++instance BoxedEnum DBusCallFlags where+    boxedEnumType _ = c_g_dbus_call_flags_get_type++instance IsGFlag DBusCallFlags++-- Flags ConverterFlags++data ConverterFlags = +      ConverterFlagsNone+    | ConverterFlagsInputAtEnd+    | ConverterFlagsFlush+    | AnotherConverterFlags Int+    deriving (Show, Eq)++instance Enum ConverterFlags where+    fromEnum ConverterFlagsNone = 0+    fromEnum ConverterFlagsInputAtEnd = 1+    fromEnum ConverterFlagsFlush = 2+    fromEnum (AnotherConverterFlags k) = k++    toEnum 0 = ConverterFlagsNone+    toEnum 1 = ConverterFlagsInputAtEnd+    toEnum 2 = ConverterFlagsFlush+    toEnum k = AnotherConverterFlags k++foreign import ccall "g_converter_flags_get_type" c_g_converter_flags_get_type :: +    IO GType++instance BoxedEnum ConverterFlags where+    boxedEnumType _ = c_g_converter_flags_get_type++instance IsGFlag ConverterFlags++-- Flags BusNameWatcherFlags++data BusNameWatcherFlags = +      BusNameWatcherFlagsNone+    | BusNameWatcherFlagsAutoStart+    | AnotherBusNameWatcherFlags Int+    deriving (Show, Eq)++instance Enum BusNameWatcherFlags where+    fromEnum BusNameWatcherFlagsNone = 0+    fromEnum BusNameWatcherFlagsAutoStart = 1+    fromEnum (AnotherBusNameWatcherFlags k) = k++    toEnum 0 = BusNameWatcherFlagsNone+    toEnum 1 = BusNameWatcherFlagsAutoStart+    toEnum k = AnotherBusNameWatcherFlags k++foreign import ccall "g_bus_name_watcher_flags_get_type" c_g_bus_name_watcher_flags_get_type :: +    IO GType++instance BoxedEnum BusNameWatcherFlags where+    boxedEnumType _ = c_g_bus_name_watcher_flags_get_type++instance IsGFlag BusNameWatcherFlags++-- Flags BusNameOwnerFlags++data BusNameOwnerFlags = +      BusNameOwnerFlagsNone+    | BusNameOwnerFlagsAllowReplacement+    | BusNameOwnerFlagsReplace+    | AnotherBusNameOwnerFlags Int+    deriving (Show, Eq)++instance Enum BusNameOwnerFlags where+    fromEnum BusNameOwnerFlagsNone = 0+    fromEnum BusNameOwnerFlagsAllowReplacement = 1+    fromEnum BusNameOwnerFlagsReplace = 2+    fromEnum (AnotherBusNameOwnerFlags k) = k++    toEnum 0 = BusNameOwnerFlagsNone+    toEnum 1 = BusNameOwnerFlagsAllowReplacement+    toEnum 2 = BusNameOwnerFlagsReplace+    toEnum k = AnotherBusNameOwnerFlags k++foreign import ccall "g_bus_name_owner_flags_get_type" c_g_bus_name_owner_flags_get_type :: +    IO GType++instance BoxedEnum BusNameOwnerFlags where+    boxedEnumType _ = c_g_bus_name_owner_flags_get_type++instance IsGFlag BusNameOwnerFlags++-- Flags AskPasswordFlags++data AskPasswordFlags = +      AskPasswordFlagsNeedPassword+    | AskPasswordFlagsNeedUsername+    | AskPasswordFlagsNeedDomain+    | AskPasswordFlagsSavingSupported+    | AskPasswordFlagsAnonymousSupported+    | AnotherAskPasswordFlags Int+    deriving (Show, Eq)++instance Enum AskPasswordFlags where+    fromEnum AskPasswordFlagsNeedPassword = 1+    fromEnum AskPasswordFlagsNeedUsername = 2+    fromEnum AskPasswordFlagsNeedDomain = 4+    fromEnum AskPasswordFlagsSavingSupported = 8+    fromEnum AskPasswordFlagsAnonymousSupported = 16+    fromEnum (AnotherAskPasswordFlags k) = k++    toEnum 1 = AskPasswordFlagsNeedPassword+    toEnum 2 = AskPasswordFlagsNeedUsername+    toEnum 4 = AskPasswordFlagsNeedDomain+    toEnum 8 = AskPasswordFlagsSavingSupported+    toEnum 16 = AskPasswordFlagsAnonymousSupported+    toEnum k = AnotherAskPasswordFlags k++foreign import ccall "g_ask_password_flags_get_type" c_g_ask_password_flags_get_type :: +    IO GType++instance BoxedEnum AskPasswordFlags where+    boxedEnumType _ = c_g_ask_password_flags_get_type++instance IsGFlag AskPasswordFlags++-- Flags ApplicationFlags++data ApplicationFlags = +      ApplicationFlagsFlagsNone+    | ApplicationFlagsIsService+    | ApplicationFlagsIsLauncher+    | ApplicationFlagsHandlesOpen+    | ApplicationFlagsHandlesCommandLine+    | ApplicationFlagsSendEnvironment+    | ApplicationFlagsNonUnique+    | AnotherApplicationFlags Int+    deriving (Show, Eq)++instance Enum ApplicationFlags where+    fromEnum ApplicationFlagsFlagsNone = 0+    fromEnum ApplicationFlagsIsService = 1+    fromEnum ApplicationFlagsIsLauncher = 2+    fromEnum ApplicationFlagsHandlesOpen = 4+    fromEnum ApplicationFlagsHandlesCommandLine = 8+    fromEnum ApplicationFlagsSendEnvironment = 16+    fromEnum ApplicationFlagsNonUnique = 32+    fromEnum (AnotherApplicationFlags k) = k++    toEnum 0 = ApplicationFlagsFlagsNone+    toEnum 1 = ApplicationFlagsIsService+    toEnum 2 = ApplicationFlagsIsLauncher+    toEnum 4 = ApplicationFlagsHandlesOpen+    toEnum 8 = ApplicationFlagsHandlesCommandLine+    toEnum 16 = ApplicationFlagsSendEnvironment+    toEnum 32 = ApplicationFlagsNonUnique+    toEnum k = AnotherApplicationFlags k++foreign import ccall "g_application_flags_get_type" c_g_application_flags_get_type :: +    IO GType++instance BoxedEnum ApplicationFlags where+    boxedEnumType _ = c_g_application_flags_get_type++instance IsGFlag ApplicationFlags++-- Flags AppInfoCreateFlags++data AppInfoCreateFlags = +      AppInfoCreateFlagsNone+    | AppInfoCreateFlagsNeedsTerminal+    | AppInfoCreateFlagsSupportsUris+    | AppInfoCreateFlagsSupportsStartupNotification+    | AnotherAppInfoCreateFlags Int+    deriving (Show, Eq)++instance Enum AppInfoCreateFlags where+    fromEnum AppInfoCreateFlagsNone = 0+    fromEnum AppInfoCreateFlagsNeedsTerminal = 1+    fromEnum AppInfoCreateFlagsSupportsUris = 2+    fromEnum AppInfoCreateFlagsSupportsStartupNotification = 4+    fromEnum (AnotherAppInfoCreateFlags k) = k++    toEnum 0 = AppInfoCreateFlagsNone+    toEnum 1 = AppInfoCreateFlagsNeedsTerminal+    toEnum 2 = AppInfoCreateFlagsSupportsUris+    toEnum 4 = AppInfoCreateFlagsSupportsStartupNotification+    toEnum k = AnotherAppInfoCreateFlags k++foreign import ccall "g_app_info_create_flags_get_type" c_g_app_info_create_flags_get_type :: +    IO GType++instance BoxedEnum AppInfoCreateFlags where+    boxedEnumType _ = c_g_app_info_create_flags_get_type++instance IsGFlag AppInfoCreateFlags++
+ GI/Gio/Functions.hs view
@@ -0,0 +1,4069 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Functions+    ( ++ -- * Methods+-- ** actionNameIsValid+    actionNameIsValid                       ,+++-- ** actionParseDetailedName+    actionParseDetailedName                 ,+++-- ** actionPrintDetailedName+    actionPrintDetailedName                 ,+++-- ** appInfoCreateFromCommandline+    appInfoCreateFromCommandline            ,+++-- ** appInfoGetAll+    appInfoGetAll                           ,+++-- ** appInfoGetAllForType+    appInfoGetAllForType                    ,+++-- ** appInfoGetDefaultForType+    appInfoGetDefaultForType                ,+++-- ** appInfoGetDefaultForUriScheme+    appInfoGetDefaultForUriScheme           ,+++-- ** appInfoGetFallbackForType+    appInfoGetFallbackForType               ,+++-- ** appInfoGetRecommendedForType+    appInfoGetRecommendedForType            ,+++-- ** appInfoLaunchDefaultForUri+    appInfoLaunchDefaultForUri              ,+++-- ** appInfoResetTypeAssociations+    appInfoResetTypeAssociations            ,+++-- ** asyncInitableNewvAsync+    asyncInitableNewvAsync                  ,+++-- ** busGet+    busGet                                  ,+++-- ** busGetFinish+    busGetFinish                            ,+++-- ** busGetSync+    busGetSync                              ,+++-- ** busOwnName+    busOwnName                              ,+++-- ** busOwnNameOnConnection+    busOwnNameOnConnection                  ,+++-- ** busUnownName+    busUnownName                            ,+++-- ** busUnwatchName+    busUnwatchName                          ,+++-- ** busWatchName+    busWatchName                            ,+++-- ** busWatchNameOnConnection+    busWatchNameOnConnection                ,+++-- ** contentTypeCanBeExecutable+    contentTypeCanBeExecutable              ,+++-- ** contentTypeEquals+    contentTypeEquals                       ,+++-- ** contentTypeFromMimeType+    contentTypeFromMimeType                 ,+++-- ** contentTypeGetDescription+    contentTypeGetDescription               ,+++-- ** contentTypeGetGenericIconName+    contentTypeGetGenericIconName           ,+++-- ** contentTypeGetIcon+    contentTypeGetIcon                      ,+++-- ** contentTypeGetMimeType+    contentTypeGetMimeType                  ,+++-- ** contentTypeGetSymbolicIcon+    contentTypeGetSymbolicIcon              ,+++-- ** contentTypeGuess+    contentTypeGuess                        ,+++-- ** contentTypeGuessForTree+    contentTypeGuessForTree                 ,+++-- ** contentTypeIsA+    contentTypeIsA                          ,+++-- ** contentTypeIsUnknown+    contentTypeIsUnknown                    ,+++-- ** contentTypesGetRegistered+    contentTypesGetRegistered               ,+++-- ** dbusAddressEscapeValue+    dbusAddressEscapeValue                  ,+++-- ** dbusAddressGetForBusSync+    dbusAddressGetForBusSync                ,+++-- ** dbusAddressGetStream+    dbusAddressGetStream                    ,+++-- ** dbusAddressGetStreamFinish+    dbusAddressGetStreamFinish              ,+++-- ** dbusAddressGetStreamSync+    dbusAddressGetStreamSync                ,+++-- ** dbusAnnotationInfoLookup+    dbusAnnotationInfoLookup                ,+++-- ** dbusErrorEncodeGerror+    dbusErrorEncodeGerror                   ,+++-- ** dbusErrorGetRemoteError+    dbusErrorGetRemoteError                 ,+++-- ** dbusErrorIsRemoteError+    dbusErrorIsRemoteError                  ,+++-- ** dbusErrorNewForDbusError+    dbusErrorNewForDbusError                ,+++-- ** dbusErrorQuark+    dbusErrorQuark                          ,+++-- ** dbusErrorRegisterError+    dbusErrorRegisterError                  ,+++-- ** dbusErrorRegisterErrorDomain+    dbusErrorRegisterErrorDomain            ,+++-- ** dbusErrorStripRemoteError+    dbusErrorStripRemoteError               ,+++-- ** dbusErrorUnregisterError+    dbusErrorUnregisterError                ,+++-- ** dbusGenerateGuid+    dbusGenerateGuid                        ,+++-- ** dbusGvalueToGvariant+    dbusGvalueToGvariant                    ,+++-- ** dbusGvariantToGvalue+    dbusGvariantToGvalue                    ,+++-- ** dbusIsAddress+    dbusIsAddress                           ,+++-- ** dbusIsGuid+    dbusIsGuid                              ,+++-- ** dbusIsInterfaceName+    dbusIsInterfaceName                     ,+++-- ** dbusIsMemberName+    dbusIsMemberName                        ,+++-- ** dbusIsName+    dbusIsName                              ,+++-- ** dbusIsSupportedAddress+    dbusIsSupportedAddress                  ,+++-- ** dbusIsUniqueName+    dbusIsUniqueName                        ,+++-- ** fileNewForCommandlineArg+    fileNewForCommandlineArg                ,+++-- ** fileNewForCommandlineArgAndCwd+    fileNewForCommandlineArgAndCwd          ,+++-- ** fileNewForPath+    fileNewForPath                          ,+++-- ** fileNewForUri+    fileNewForUri                           ,+++-- ** fileNewTmp+    fileNewTmp                              ,+++-- ** fileParseName+    fileParseName                           ,+++-- ** iconDeserialize+    iconDeserialize                         ,+++-- ** iconHash+    iconHash                                ,+++-- ** iconNewForString+    iconNewForString                        ,+++-- ** initableNewv+    initableNewv                            ,+++-- ** ioErrorFromErrno+    ioErrorFromErrno                        ,+++-- ** ioErrorQuark+    ioErrorQuark                            ,+++-- ** ioExtensionPointImplement+    ioExtensionPointImplement               ,+++-- ** ioExtensionPointLookup+    ioExtensionPointLookup                  ,+++-- ** ioExtensionPointRegister+    ioExtensionPointRegister                ,+++-- ** ioModulesScanAllInDirectory+    ioModulesScanAllInDirectory             ,+++-- ** ioModulesScanAllInDirectoryWithScope+    ioModulesScanAllInDirectoryWithScope    ,+++-- ** ioSchedulerCancelAllJobs+    ioSchedulerCancelAllJobs                ,+++-- ** ioSchedulerPushJob+    ioSchedulerPushJob                      ,+++-- ** networkMonitorGetDefault+    networkMonitorGetDefault                ,+++-- ** networkingInit+    networkingInit                          ,+++-- ** pollableSourceNew+    pollableSourceNew                       ,+++-- ** pollableSourceNewFull+    pollableSourceNewFull                   ,+++-- ** pollableStreamRead+    pollableStreamRead                      ,+++-- ** pollableStreamWrite+    pollableStreamWrite                     ,+++-- ** pollableStreamWriteAll+    pollableStreamWriteAll                  ,+++-- ** proxyGetDefaultForProtocol+    proxyGetDefaultForProtocol              ,+++-- ** proxyResolverGetDefault+    proxyResolverGetDefault                 ,+++-- ** resolverErrorQuark+    resolverErrorQuark                      ,+++-- ** resourceErrorQuark+    resourceErrorQuark                      ,+++-- ** resourceLoad+    resourceLoad                            ,+++-- ** resourcesEnumerateChildren+    resourcesEnumerateChildren              ,+++-- ** resourcesGetInfo+    resourcesGetInfo                        ,+++-- ** resourcesLookupData+    resourcesLookupData                     ,+++-- ** resourcesOpenStream+    resourcesOpenStream                     ,+++-- ** resourcesRegister+    resourcesRegister                       ,+++-- ** resourcesUnregister+    resourcesUnregister                     ,+++-- ** settingsSchemaSourceGetDefault+    settingsSchemaSourceGetDefault          ,+++-- ** simpleAsyncReportGerrorInIdle+    simpleAsyncReportGerrorInIdle           ,+++-- ** tlsBackendGetDefault+    tlsBackendGetDefault                    ,+++-- ** tlsClientConnectionNew+    tlsClientConnectionNew                  ,+++-- ** tlsErrorQuark+    tlsErrorQuark                           ,+++-- ** tlsFileDatabaseNew+    tlsFileDatabaseNew                      ,+++-- ** tlsServerConnectionNew+    tlsServerConnectionNew                  ,+++-- ** unixIsMountPathSystemInternal+    unixIsMountPathSystemInternal           ,+++-- ** unixMountCompare+    unixMountCompare                        ,+++-- ** unixMountFree+    unixMountFree                           ,+++-- ** unixMountGetDevicePath+    unixMountGetDevicePath                  ,+++-- ** unixMountGetFsType+    unixMountGetFsType                      ,+++-- ** unixMountGetMountPath+    unixMountGetMountPath                   ,+++-- ** unixMountGuessCanEject+    unixMountGuessCanEject                  ,+++-- ** unixMountGuessIcon+    unixMountGuessIcon                      ,+++-- ** unixMountGuessName+    unixMountGuessName                      ,+++-- ** unixMountGuessShouldDisplay+    unixMountGuessShouldDisplay             ,+++-- ** unixMountGuessSymbolicIcon+    unixMountGuessSymbolicIcon              ,+++-- ** unixMountIsReadonly+    unixMountIsReadonly                     ,+++-- ** unixMountIsSystemInternal+    unixMountIsSystemInternal               ,+++-- ** unixMountPointsChangedSince+    unixMountPointsChangedSince             ,+++-- ** unixMountsChangedSince+    unixMountsChangedSince                  ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++-- function g_unix_mounts_changed_since+-- Args : [Arg {argName = "time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_mounts_changed_since" g_unix_mounts_changed_since :: +    Word64 ->                               -- time : TBasicType TUInt64+    IO CInt+++unixMountsChangedSince ::+    (MonadIO m) =>+    Word64 ->                               -- time+    m Bool+unixMountsChangedSince time = liftIO $ do+    result <- g_unix_mounts_changed_since time+    let result' = (/= 0) result+    return result'+++-- function g_unix_mount_points_changed_since+-- Args : [Arg {argName = "time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_mount_points_changed_since" g_unix_mount_points_changed_since :: +    Word64 ->                               -- time : TBasicType TUInt64+    IO CInt+++unixMountPointsChangedSince ::+    (MonadIO m) =>+    Word64 ->                               -- time+    m Bool+unixMountPointsChangedSince time = liftIO $ do+    result <- g_unix_mount_points_changed_since time+    let result' = (/= 0) result+    return result'+++-- function g_unix_mount_is_system_internal+-- Args : [Arg {argName = "mount_entry", argType = TInterface "Gio" "UnixMountEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "mount_entry", argType = TInterface "Gio" "UnixMountEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_mount_is_system_internal" g_unix_mount_is_system_internal :: +    Ptr UnixMountEntry ->                   -- mount_entry : TInterface "Gio" "UnixMountEntry"+    IO CInt+++unixMountIsSystemInternal ::+    (MonadIO m) =>+    UnixMountEntry ->                       -- mount_entry+    m Bool+unixMountIsSystemInternal mount_entry = liftIO $ do+    let mount_entry' = unsafeManagedPtrGetPtr mount_entry+    result <- g_unix_mount_is_system_internal mount_entry'+    let result' = (/= 0) result+    touchManagedPtr mount_entry+    return result'+++-- function g_unix_mount_is_readonly+-- Args : [Arg {argName = "mount_entry", argType = TInterface "Gio" "UnixMountEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "mount_entry", argType = TInterface "Gio" "UnixMountEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_mount_is_readonly" g_unix_mount_is_readonly :: +    Ptr UnixMountEntry ->                   -- mount_entry : TInterface "Gio" "UnixMountEntry"+    IO CInt+++unixMountIsReadonly ::+    (MonadIO m) =>+    UnixMountEntry ->                       -- mount_entry+    m Bool+unixMountIsReadonly mount_entry = liftIO $ do+    let mount_entry' = unsafeManagedPtrGetPtr mount_entry+    result <- g_unix_mount_is_readonly mount_entry'+    let result' = (/= 0) result+    touchManagedPtr mount_entry+    return result'+++-- function g_unix_mount_guess_symbolic_icon+-- Args : [Arg {argName = "mount_entry", argType = TInterface "Gio" "UnixMountEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "mount_entry", argType = TInterface "Gio" "UnixMountEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Icon"+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_mount_guess_symbolic_icon" g_unix_mount_guess_symbolic_icon :: +    Ptr UnixMountEntry ->                   -- mount_entry : TInterface "Gio" "UnixMountEntry"+    IO (Ptr Icon)+++unixMountGuessSymbolicIcon ::+    (MonadIO m) =>+    UnixMountEntry ->                       -- mount_entry+    m Icon+unixMountGuessSymbolicIcon mount_entry = liftIO $ do+    let mount_entry' = unsafeManagedPtrGetPtr mount_entry+    result <- g_unix_mount_guess_symbolic_icon mount_entry'+    checkUnexpectedReturnNULL "g_unix_mount_guess_symbolic_icon" result+    result' <- (wrapObject Icon) result+    touchManagedPtr mount_entry+    return result'+++-- function g_unix_mount_guess_should_display+-- Args : [Arg {argName = "mount_entry", argType = TInterface "Gio" "UnixMountEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "mount_entry", argType = TInterface "Gio" "UnixMountEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_mount_guess_should_display" g_unix_mount_guess_should_display :: +    Ptr UnixMountEntry ->                   -- mount_entry : TInterface "Gio" "UnixMountEntry"+    IO CInt+++unixMountGuessShouldDisplay ::+    (MonadIO m) =>+    UnixMountEntry ->                       -- mount_entry+    m Bool+unixMountGuessShouldDisplay mount_entry = liftIO $ do+    let mount_entry' = unsafeManagedPtrGetPtr mount_entry+    result <- g_unix_mount_guess_should_display mount_entry'+    let result' = (/= 0) result+    touchManagedPtr mount_entry+    return result'+++-- function g_unix_mount_guess_name+-- Args : [Arg {argName = "mount_entry", argType = TInterface "Gio" "UnixMountEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "mount_entry", argType = TInterface "Gio" "UnixMountEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_mount_guess_name" g_unix_mount_guess_name :: +    Ptr UnixMountEntry ->                   -- mount_entry : TInterface "Gio" "UnixMountEntry"+    IO CString+++unixMountGuessName ::+    (MonadIO m) =>+    UnixMountEntry ->                       -- mount_entry+    m T.Text+unixMountGuessName mount_entry = liftIO $ do+    let mount_entry' = unsafeManagedPtrGetPtr mount_entry+    result <- g_unix_mount_guess_name mount_entry'+    checkUnexpectedReturnNULL "g_unix_mount_guess_name" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr mount_entry+    return result'+++-- function g_unix_mount_guess_icon+-- Args : [Arg {argName = "mount_entry", argType = TInterface "Gio" "UnixMountEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "mount_entry", argType = TInterface "Gio" "UnixMountEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Icon"+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_mount_guess_icon" g_unix_mount_guess_icon :: +    Ptr UnixMountEntry ->                   -- mount_entry : TInterface "Gio" "UnixMountEntry"+    IO (Ptr Icon)+++unixMountGuessIcon ::+    (MonadIO m) =>+    UnixMountEntry ->                       -- mount_entry+    m Icon+unixMountGuessIcon mount_entry = liftIO $ do+    let mount_entry' = unsafeManagedPtrGetPtr mount_entry+    result <- g_unix_mount_guess_icon mount_entry'+    checkUnexpectedReturnNULL "g_unix_mount_guess_icon" result+    result' <- (wrapObject Icon) result+    touchManagedPtr mount_entry+    return result'+++-- function g_unix_mount_guess_can_eject+-- Args : [Arg {argName = "mount_entry", argType = TInterface "Gio" "UnixMountEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "mount_entry", argType = TInterface "Gio" "UnixMountEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_mount_guess_can_eject" g_unix_mount_guess_can_eject :: +    Ptr UnixMountEntry ->                   -- mount_entry : TInterface "Gio" "UnixMountEntry"+    IO CInt+++unixMountGuessCanEject ::+    (MonadIO m) =>+    UnixMountEntry ->                       -- mount_entry+    m Bool+unixMountGuessCanEject mount_entry = liftIO $ do+    let mount_entry' = unsafeManagedPtrGetPtr mount_entry+    result <- g_unix_mount_guess_can_eject mount_entry'+    let result' = (/= 0) result+    touchManagedPtr mount_entry+    return result'+++-- function g_unix_mount_get_mount_path+-- Args : [Arg {argName = "mount_entry", argType = TInterface "Gio" "UnixMountEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "mount_entry", argType = TInterface "Gio" "UnixMountEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_mount_get_mount_path" g_unix_mount_get_mount_path :: +    Ptr UnixMountEntry ->                   -- mount_entry : TInterface "Gio" "UnixMountEntry"+    IO CString+++unixMountGetMountPath ::+    (MonadIO m) =>+    UnixMountEntry ->                       -- mount_entry+    m T.Text+unixMountGetMountPath mount_entry = liftIO $ do+    let mount_entry' = unsafeManagedPtrGetPtr mount_entry+    result <- g_unix_mount_get_mount_path mount_entry'+    checkUnexpectedReturnNULL "g_unix_mount_get_mount_path" result+    result' <- cstringToText result+    touchManagedPtr mount_entry+    return result'+++-- function g_unix_mount_get_fs_type+-- Args : [Arg {argName = "mount_entry", argType = TInterface "Gio" "UnixMountEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "mount_entry", argType = TInterface "Gio" "UnixMountEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_mount_get_fs_type" g_unix_mount_get_fs_type :: +    Ptr UnixMountEntry ->                   -- mount_entry : TInterface "Gio" "UnixMountEntry"+    IO CString+++unixMountGetFsType ::+    (MonadIO m) =>+    UnixMountEntry ->                       -- mount_entry+    m T.Text+unixMountGetFsType mount_entry = liftIO $ do+    let mount_entry' = unsafeManagedPtrGetPtr mount_entry+    result <- g_unix_mount_get_fs_type mount_entry'+    checkUnexpectedReturnNULL "g_unix_mount_get_fs_type" result+    result' <- cstringToText result+    touchManagedPtr mount_entry+    return result'+++-- function g_unix_mount_get_device_path+-- Args : [Arg {argName = "mount_entry", argType = TInterface "Gio" "UnixMountEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "mount_entry", argType = TInterface "Gio" "UnixMountEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_mount_get_device_path" g_unix_mount_get_device_path :: +    Ptr UnixMountEntry ->                   -- mount_entry : TInterface "Gio" "UnixMountEntry"+    IO CString+++unixMountGetDevicePath ::+    (MonadIO m) =>+    UnixMountEntry ->                       -- mount_entry+    m T.Text+unixMountGetDevicePath mount_entry = liftIO $ do+    let mount_entry' = unsafeManagedPtrGetPtr mount_entry+    result <- g_unix_mount_get_device_path mount_entry'+    checkUnexpectedReturnNULL "g_unix_mount_get_device_path" result+    result' <- cstringToText result+    touchManagedPtr mount_entry+    return result'+++-- function g_unix_mount_free+-- Args : [Arg {argName = "mount_entry", argType = TInterface "Gio" "UnixMountEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "mount_entry", argType = TInterface "Gio" "UnixMountEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_mount_free" g_unix_mount_free :: +    Ptr UnixMountEntry ->                   -- mount_entry : TInterface "Gio" "UnixMountEntry"+    IO ()+++unixMountFree ::+    (MonadIO m) =>+    UnixMountEntry ->                       -- mount_entry+    m ()+unixMountFree mount_entry = liftIO $ do+    let mount_entry' = unsafeManagedPtrGetPtr mount_entry+    g_unix_mount_free mount_entry'+    touchManagedPtr mount_entry+    return ()+++-- function g_unix_mount_compare+-- Args : [Arg {argName = "mount1", argType = TInterface "Gio" "UnixMountEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mount2", argType = TInterface "Gio" "UnixMountEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "mount1", argType = TInterface "Gio" "UnixMountEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mount2", argType = TInterface "Gio" "UnixMountEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_mount_compare" g_unix_mount_compare :: +    Ptr UnixMountEntry ->                   -- mount1 : TInterface "Gio" "UnixMountEntry"+    Ptr UnixMountEntry ->                   -- mount2 : TInterface "Gio" "UnixMountEntry"+    IO Int32+++unixMountCompare ::+    (MonadIO m) =>+    UnixMountEntry ->                       -- mount1+    UnixMountEntry ->                       -- mount2+    m Int32+unixMountCompare mount1 mount2 = liftIO $ do+    let mount1' = unsafeManagedPtrGetPtr mount1+    let mount2' = unsafeManagedPtrGetPtr mount2+    result <- g_unix_mount_compare mount1' mount2'+    touchManagedPtr mount1+    touchManagedPtr mount2+    return result+++-- function g_unix_is_mount_path_system_internal+-- Args : [Arg {argName = "mount_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "mount_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_is_mount_path_system_internal" g_unix_is_mount_path_system_internal :: +    CString ->                              -- mount_path : TBasicType TUTF8+    IO CInt+++unixIsMountPathSystemInternal ::+    (MonadIO m) =>+    T.Text ->                               -- mount_path+    m Bool+unixIsMountPathSystemInternal mount_path = liftIO $ do+    mount_path' <- textToCString mount_path+    result <- g_unix_is_mount_path_system_internal mount_path'+    let result' = (/= 0) result+    freeMem mount_path'+    return result'+++-- function g_tls_server_connection_new+-- Args : [Arg {argName = "base_io_stream", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "certificate", argType = TInterface "Gio" "TlsCertificate", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "base_io_stream", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "certificate", argType = TInterface "Gio" "TlsCertificate", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TlsServerConnection"+-- throws : True+-- Skip return : False++foreign import ccall "g_tls_server_connection_new" g_tls_server_connection_new :: +    Ptr IOStream ->                         -- base_io_stream : TInterface "Gio" "IOStream"+    Ptr TlsCertificate ->                   -- certificate : TInterface "Gio" "TlsCertificate"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr TlsServerConnection)+++tlsServerConnectionNew ::+    (MonadIO m, IOStreamK a, TlsCertificateK b) =>+    a ->                                    -- base_io_stream+    Maybe (b) ->                            -- certificate+    m TlsServerConnection+tlsServerConnectionNew base_io_stream certificate = liftIO $ do+    let base_io_stream' = unsafeManagedPtrCastPtr base_io_stream+    maybeCertificate <- case certificate of+        Nothing -> return nullPtr+        Just jCertificate -> do+            let jCertificate' = unsafeManagedPtrCastPtr jCertificate+            return jCertificate'+    onException (do+        result <- propagateGError $ g_tls_server_connection_new base_io_stream' maybeCertificate+        checkUnexpectedReturnNULL "g_tls_server_connection_new" result+        result' <- (wrapObject TlsServerConnection) result+        touchManagedPtr base_io_stream+        whenJust certificate touchManagedPtr+        return result'+     ) (do+        return ()+     )+++-- function g_tls_file_database_new+-- Args : [Arg {argName = "anchors", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "anchors", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TlsFileDatabase"+-- throws : True+-- Skip return : False++foreign import ccall "g_tls_file_database_new" g_tls_file_database_new :: +    CString ->                              -- anchors : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr TlsFileDatabase)+++tlsFileDatabaseNew ::+    (MonadIO m) =>+    T.Text ->                               -- anchors+    m TlsFileDatabase+tlsFileDatabaseNew anchors = liftIO $ do+    anchors' <- textToCString anchors+    onException (do+        result <- propagateGError $ g_tls_file_database_new anchors'+        checkUnexpectedReturnNULL "g_tls_file_database_new" result+        result' <- (wrapObject TlsFileDatabase) result+        freeMem anchors'+        return result'+     ) (do+        freeMem anchors'+     )+++-- function g_tls_error_quark+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_error_quark" g_tls_error_quark :: +    IO Word32+++tlsErrorQuark ::+    (MonadIO m) =>+    m Word32+tlsErrorQuark  = liftIO $ do+    result <- g_tls_error_quark+    return result+++-- function g_tls_client_connection_new+-- Args : [Arg {argName = "base_io_stream", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "server_identity", argType = TInterface "Gio" "SocketConnectable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "base_io_stream", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "server_identity", argType = TInterface "Gio" "SocketConnectable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TlsClientConnection"+-- throws : True+-- Skip return : False++foreign import ccall "g_tls_client_connection_new" g_tls_client_connection_new :: +    Ptr IOStream ->                         -- base_io_stream : TInterface "Gio" "IOStream"+    Ptr SocketConnectable ->                -- server_identity : TInterface "Gio" "SocketConnectable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr TlsClientConnection)+++tlsClientConnectionNew ::+    (MonadIO m, IOStreamK a, SocketConnectableK b) =>+    a ->                                    -- base_io_stream+    Maybe (b) ->                            -- server_identity+    m TlsClientConnection+tlsClientConnectionNew base_io_stream server_identity = liftIO $ do+    let base_io_stream' = unsafeManagedPtrCastPtr base_io_stream+    maybeServer_identity <- case server_identity of+        Nothing -> return nullPtr+        Just jServer_identity -> do+            let jServer_identity' = unsafeManagedPtrCastPtr jServer_identity+            return jServer_identity'+    onException (do+        result <- propagateGError $ g_tls_client_connection_new base_io_stream' maybeServer_identity+        checkUnexpectedReturnNULL "g_tls_client_connection_new" result+        result' <- (wrapObject TlsClientConnection) result+        touchManagedPtr base_io_stream+        whenJust server_identity touchManagedPtr+        return result'+     ) (do+        return ()+     )+++-- function g_tls_backend_get_default+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gio" "TlsBackend"+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_backend_get_default" g_tls_backend_get_default :: +    IO (Ptr TlsBackend)+++tlsBackendGetDefault ::+    (MonadIO m) =>+    m TlsBackend+tlsBackendGetDefault  = liftIO $ do+    result <- g_tls_backend_get_default+    checkUnexpectedReturnNULL "g_tls_backend_get_default" result+    result' <- (newObject TlsBackend) result+    return result'+++-- function g_simple_async_report_gerror_in_idle+-- Args : [Arg {argName = "object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 2, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 2, argDestroy = -1, transfer = TransferNothing},Arg {argName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_simple_async_report_gerror_in_idle" g_simple_async_report_gerror_in_idle :: +    Ptr GObject.Object ->                   -- object : TInterface "GObject" "Object"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    Ptr GError ->                           -- error : TError+    IO ()++{-# DEPRECATED simpleAsyncReportGerrorInIdle ["(Since version 2.46)","Use g_task_report_error()."]#-}+simpleAsyncReportGerrorInIdle ::+    (MonadIO m, GObject.ObjectK a) =>+    Maybe (a) ->                            -- object+    Maybe (AsyncReadyCallback) ->           -- callback+    GError ->                               -- error+    m ()+simpleAsyncReportGerrorInIdle object callback error_ = liftIO $ do+    maybeObject <- case object of+        Nothing -> return nullPtr+        Just jObject -> do+            let jObject' = unsafeManagedPtrCastPtr jObject+            return jObject'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let error_' = unsafeManagedPtrGetPtr error_+    let user_data = nullPtr+    g_simple_async_report_gerror_in_idle maybeObject maybeCallback user_data error_'+    whenJust object touchManagedPtr+    touchManagedPtr error_+    return ()+++-- function g_settings_schema_source_get_default+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gio" "SettingsSchemaSource"+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_schema_source_get_default" g_settings_schema_source_get_default :: +    IO (Ptr SettingsSchemaSource)+++settingsSchemaSourceGetDefault ::+    (MonadIO m) =>+    m SettingsSchemaSource+settingsSchemaSourceGetDefault  = liftIO $ do+    result <- g_settings_schema_source_get_default+    checkUnexpectedReturnNULL "g_settings_schema_source_get_default" result+    result' <- (newBoxed SettingsSchemaSource) result+    return result'+++-- function g_resources_unregister+-- Args : [Arg {argName = "resource", argType = TInterface "Gio" "Resource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "resource", argType = TInterface "Gio" "Resource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_resources_unregister" g_resources_unregister :: +    Ptr Resource ->                         -- resource : TInterface "Gio" "Resource"+    IO ()+++resourcesUnregister ::+    (MonadIO m) =>+    Resource ->                             -- resource+    m ()+resourcesUnregister resource = liftIO $ do+    let resource' = unsafeManagedPtrGetPtr resource+    g_resources_unregister resource'+    touchManagedPtr resource+    return ()+++-- function g_resources_register+-- Args : [Arg {argName = "resource", argType = TInterface "Gio" "Resource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "resource", argType = TInterface "Gio" "Resource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_resources_register" g_resources_register :: +    Ptr Resource ->                         -- resource : TInterface "Gio" "Resource"+    IO ()+++resourcesRegister ::+    (MonadIO m) =>+    Resource ->                             -- resource+    m ()+resourcesRegister resource = liftIO $ do+    let resource' = unsafeManagedPtrGetPtr resource+    g_resources_register resource'+    touchManagedPtr resource+    return ()+++-- function g_resources_open_stream+-- Args : [Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "lookup_flags", argType = TInterface "Gio" "ResourceLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "lookup_flags", argType = TInterface "Gio" "ResourceLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "InputStream"+-- throws : True+-- Skip return : False++foreign import ccall "g_resources_open_stream" g_resources_open_stream :: +    CString ->                              -- path : TBasicType TUTF8+    CUInt ->                                -- lookup_flags : TInterface "Gio" "ResourceLookupFlags"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr InputStream)+++resourcesOpenStream ::+    (MonadIO m) =>+    T.Text ->                               -- path+    [ResourceLookupFlags] ->                -- lookup_flags+    m InputStream+resourcesOpenStream path lookup_flags = liftIO $ do+    path' <- textToCString path+    let lookup_flags' = gflagsToWord lookup_flags+    onException (do+        result <- propagateGError $ g_resources_open_stream path' lookup_flags'+        checkUnexpectedReturnNULL "g_resources_open_stream" result+        result' <- (wrapObject InputStream) result+        freeMem path'+        return result'+     ) (do+        freeMem path'+     )+++-- function g_resources_lookup_data+-- Args : [Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "lookup_flags", argType = TInterface "Gio" "ResourceLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "lookup_flags", argType = TInterface "Gio" "ResourceLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GLib" "Bytes"+-- throws : True+-- Skip return : False++foreign import ccall "g_resources_lookup_data" g_resources_lookup_data :: +    CString ->                              -- path : TBasicType TUTF8+    CUInt ->                                -- lookup_flags : TInterface "Gio" "ResourceLookupFlags"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr GLib.Bytes)+++resourcesLookupData ::+    (MonadIO m) =>+    T.Text ->                               -- path+    [ResourceLookupFlags] ->                -- lookup_flags+    m GLib.Bytes+resourcesLookupData path lookup_flags = liftIO $ do+    path' <- textToCString path+    let lookup_flags' = gflagsToWord lookup_flags+    onException (do+        result <- propagateGError $ g_resources_lookup_data path' lookup_flags'+        checkUnexpectedReturnNULL "g_resources_lookup_data" result+        result' <- (wrapBoxed GLib.Bytes) result+        freeMem path'+        return result'+     ) (do+        freeMem path'+     )+++-- function g_resources_get_info+-- Args : [Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "lookup_flags", argType = TInterface "Gio" "ResourceLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "flags", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "lookup_flags", argType = TInterface "Gio" "ResourceLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_resources_get_info" g_resources_get_info :: +    CString ->                              -- path : TBasicType TUTF8+    CUInt ->                                -- lookup_flags : TInterface "Gio" "ResourceLookupFlags"+    Ptr Word64 ->                           -- size : TBasicType TUInt64+    Ptr Word32 ->                           -- flags : TBasicType TUInt32+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++resourcesGetInfo ::+    (MonadIO m) =>+    T.Text ->                               -- path+    [ResourceLookupFlags] ->                -- lookup_flags+    m (Word64,Word32)+resourcesGetInfo path lookup_flags = liftIO $ do+    path' <- textToCString path+    let lookup_flags' = gflagsToWord lookup_flags+    size <- allocMem :: IO (Ptr Word64)+    flags <- allocMem :: IO (Ptr Word32)+    onException (do+        _ <- propagateGError $ g_resources_get_info path' lookup_flags' size flags+        size' <- peek size+        flags' <- peek flags+        freeMem path'+        freeMem size+        freeMem flags+        return (size', flags')+     ) (do+        freeMem path'+        freeMem size+        freeMem flags+     )+++-- function g_resources_enumerate_children+-- Args : [Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "lookup_flags", argType = TInterface "Gio" "ResourceLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "lookup_flags", argType = TInterface "Gio" "ResourceLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : True+-- Skip return : False++foreign import ccall "g_resources_enumerate_children" g_resources_enumerate_children :: +    CString ->                              -- path : TBasicType TUTF8+    CUInt ->                                -- lookup_flags : TInterface "Gio" "ResourceLookupFlags"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr CString)+++resourcesEnumerateChildren ::+    (MonadIO m) =>+    T.Text ->                               -- path+    [ResourceLookupFlags] ->                -- lookup_flags+    m [T.Text]+resourcesEnumerateChildren path lookup_flags = liftIO $ do+    path' <- textToCString path+    let lookup_flags' = gflagsToWord lookup_flags+    onException (do+        result <- propagateGError $ g_resources_enumerate_children path' lookup_flags'+        checkUnexpectedReturnNULL "g_resources_enumerate_children" result+        result' <- unpackZeroTerminatedUTF8CArray result+        mapZeroTerminatedCArray freeMem result+        freeMem result+        freeMem path'+        return result'+     ) (do+        freeMem path'+     )+++-- function g_resource_load+-- Args : [Arg {argName = "filename", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "filename", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Resource"+-- throws : True+-- Skip return : False++foreign import ccall "g_resource_load" g_resource_load :: +    CString ->                              -- filename : TBasicType TFileName+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Resource)+++resourceLoad ::+    (MonadIO m) =>+    [Char] ->                               -- filename+    m Resource+resourceLoad filename = liftIO $ do+    filename' <- stringToCString filename+    onException (do+        result <- propagateGError $ g_resource_load filename'+        checkUnexpectedReturnNULL "g_resource_load" result+        result' <- (wrapBoxed Resource) result+        freeMem filename'+        return result'+     ) (do+        freeMem filename'+     )+++-- function g_resource_error_quark+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_resource_error_quark" g_resource_error_quark :: +    IO Word32+++resourceErrorQuark ::+    (MonadIO m) =>+    m Word32+resourceErrorQuark  = liftIO $ do+    result <- g_resource_error_quark+    return result+++-- function g_resolver_error_quark+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_resolver_error_quark" g_resolver_error_quark :: +    IO Word32+++resolverErrorQuark ::+    (MonadIO m) =>+    m Word32+resolverErrorQuark  = liftIO $ do+    result <- g_resolver_error_quark+    return result+++-- function g_proxy_resolver_get_default+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gio" "ProxyResolver"+-- throws : False+-- Skip return : False++foreign import ccall "g_proxy_resolver_get_default" g_proxy_resolver_get_default :: +    IO (Ptr ProxyResolver)+++proxyResolverGetDefault ::+    (MonadIO m) =>+    m ProxyResolver+proxyResolverGetDefault  = liftIO $ do+    result <- g_proxy_resolver_get_default+    checkUnexpectedReturnNULL "g_proxy_resolver_get_default" result+    result' <- (newObject ProxyResolver) result+    return result'+++-- function g_proxy_get_default_for_protocol+-- Args : [Arg {argName = "protocol", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "protocol", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Proxy"+-- throws : False+-- Skip return : False++foreign import ccall "g_proxy_get_default_for_protocol" g_proxy_get_default_for_protocol :: +    CString ->                              -- protocol : TBasicType TUTF8+    IO (Ptr Proxy)+++proxyGetDefaultForProtocol ::+    (MonadIO m) =>+    T.Text ->                               -- protocol+    m Proxy+proxyGetDefaultForProtocol protocol = liftIO $ do+    protocol' <- textToCString protocol+    result <- g_proxy_get_default_for_protocol protocol'+    checkUnexpectedReturnNULL "g_proxy_get_default_for_protocol" result+    result' <- (wrapObject Proxy) result+    freeMem protocol'+    return result'+++-- function g_pollable_stream_write_all+-- Args : [Arg {argName = "stream", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "blocking", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "bytes_written", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "stream", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "blocking", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_pollable_stream_write_all" g_pollable_stream_write_all :: +    Ptr OutputStream ->                     -- stream : TInterface "Gio" "OutputStream"+    Ptr Word8 ->                            -- buffer : TCArray False (-1) 2 (TBasicType TUInt8)+    Word64 ->                               -- count : TBasicType TUInt64+    CInt ->                                 -- blocking : TBasicType TBoolean+    Ptr Word64 ->                           -- bytes_written : TBasicType TUInt64+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++pollableStreamWriteAll ::+    (MonadIO m, OutputStreamK a, CancellableK b) =>+    a ->                                    -- stream+    ByteString ->                           -- buffer+    Bool ->                                 -- blocking+    Maybe (b) ->                            -- cancellable+    m (Word64)+pollableStreamWriteAll stream buffer blocking cancellable = liftIO $ do+    let count = fromIntegral $ B.length buffer+    let stream' = unsafeManagedPtrCastPtr stream+    buffer' <- packByteString buffer+    let blocking' = (fromIntegral . fromEnum) blocking+    bytes_written <- allocMem :: IO (Ptr Word64)+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_pollable_stream_write_all stream' buffer' count blocking' bytes_written maybeCancellable+        bytes_written' <- peek bytes_written+        touchManagedPtr stream+        whenJust cancellable touchManagedPtr+        freeMem buffer'+        freeMem bytes_written+        return bytes_written'+     ) (do+        freeMem buffer'+        freeMem bytes_written+     )+++-- function g_pollable_stream_write+-- Args : [Arg {argName = "stream", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "blocking", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "stream", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "blocking", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : True+-- Skip return : False++foreign import ccall "g_pollable_stream_write" g_pollable_stream_write :: +    Ptr OutputStream ->                     -- stream : TInterface "Gio" "OutputStream"+    Ptr Word8 ->                            -- buffer : TCArray False (-1) 2 (TBasicType TUInt8)+    Word64 ->                               -- count : TBasicType TUInt64+    CInt ->                                 -- blocking : TBasicType TBoolean+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO Int64+++pollableStreamWrite ::+    (MonadIO m, OutputStreamK a, CancellableK b) =>+    a ->                                    -- stream+    ByteString ->                           -- buffer+    Bool ->                                 -- blocking+    Maybe (b) ->                            -- cancellable+    m Int64+pollableStreamWrite stream buffer blocking cancellable = liftIO $ do+    let count = fromIntegral $ B.length buffer+    let stream' = unsafeManagedPtrCastPtr stream+    buffer' <- packByteString buffer+    let blocking' = (fromIntegral . fromEnum) blocking+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_pollable_stream_write stream' buffer' count blocking' maybeCancellable+        touchManagedPtr stream+        whenJust cancellable touchManagedPtr+        freeMem buffer'+        return result+     ) (do+        freeMem buffer'+     )+++-- function g_pollable_stream_read+-- Args : [Arg {argName = "stream", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "blocking", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "stream", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "blocking", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : True+-- Skip return : False++foreign import ccall "g_pollable_stream_read" g_pollable_stream_read :: +    Ptr InputStream ->                      -- stream : TInterface "Gio" "InputStream"+    Ptr Word8 ->                            -- buffer : TCArray False (-1) 2 (TBasicType TUInt8)+    Word64 ->                               -- count : TBasicType TUInt64+    CInt ->                                 -- blocking : TBasicType TBoolean+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO Int64+++pollableStreamRead ::+    (MonadIO m, InputStreamK a, CancellableK b) =>+    a ->                                    -- stream+    ByteString ->                           -- buffer+    Bool ->                                 -- blocking+    Maybe (b) ->                            -- cancellable+    m Int64+pollableStreamRead stream buffer blocking cancellable = liftIO $ do+    let count = fromIntegral $ B.length buffer+    let stream' = unsafeManagedPtrCastPtr stream+    buffer' <- packByteString buffer+    let blocking' = (fromIntegral . fromEnum) blocking+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_pollable_stream_read stream' buffer' count blocking' maybeCancellable+        touchManagedPtr stream+        whenJust cancellable touchManagedPtr+        freeMem buffer'+        return result+     ) (do+        freeMem buffer'+     )+++-- function g_pollable_source_new_full+-- Args : [Arg {argName = "pollable_stream", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child_source", argType = TInterface "GLib" "Source", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "pollable_stream", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child_source", argType = TInterface "GLib" "Source", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GLib" "Source"+-- throws : False+-- Skip return : False++foreign import ccall "g_pollable_source_new_full" g_pollable_source_new_full :: +    Ptr GObject.Object ->                   -- pollable_stream : TInterface "GObject" "Object"+    Ptr GLib.Source ->                      -- child_source : TInterface "GLib" "Source"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    IO (Ptr GLib.Source)+++pollableSourceNewFull ::+    (MonadIO m, GObject.ObjectK a, CancellableK b) =>+    a ->                                    -- pollable_stream+    Maybe (GLib.Source) ->                  -- child_source+    Maybe (b) ->                            -- cancellable+    m GLib.Source+pollableSourceNewFull pollable_stream child_source cancellable = liftIO $ do+    let pollable_stream' = unsafeManagedPtrCastPtr pollable_stream+    maybeChild_source <- case child_source of+        Nothing -> return nullPtr+        Just jChild_source -> do+            let jChild_source' = unsafeManagedPtrGetPtr jChild_source+            return jChild_source'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    result <- g_pollable_source_new_full pollable_stream' maybeChild_source maybeCancellable+    checkUnexpectedReturnNULL "g_pollable_source_new_full" result+    result' <- (wrapBoxed GLib.Source) result+    touchManagedPtr pollable_stream+    whenJust child_source touchManagedPtr+    whenJust cancellable touchManagedPtr+    return result'+++-- function g_pollable_source_new+-- Args : [Arg {argName = "pollable_stream", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "pollable_stream", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GLib" "Source"+-- throws : False+-- Skip return : False++foreign import ccall "g_pollable_source_new" g_pollable_source_new :: +    Ptr GObject.Object ->                   -- pollable_stream : TInterface "GObject" "Object"+    IO (Ptr GLib.Source)+++pollableSourceNew ::+    (MonadIO m, GObject.ObjectK a) =>+    a ->                                    -- pollable_stream+    m GLib.Source+pollableSourceNew pollable_stream = liftIO $ do+    let pollable_stream' = unsafeManagedPtrCastPtr pollable_stream+    result <- g_pollable_source_new pollable_stream'+    checkUnexpectedReturnNULL "g_pollable_source_new" result+    result' <- (wrapBoxed GLib.Source) result+    touchManagedPtr pollable_stream+    return result'+++-- function g_networking_init+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_networking_init" g_networking_init :: +    IO ()+++networkingInit ::+    (MonadIO m) =>+    m ()+networkingInit  = liftIO $ do+    g_networking_init+    return ()+++-- function g_network_monitor_get_default+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gio" "NetworkMonitor"+-- throws : False+-- Skip return : False++foreign import ccall "g_network_monitor_get_default" g_network_monitor_get_default :: +    IO (Ptr NetworkMonitor)+++networkMonitorGetDefault ::+    (MonadIO m) =>+    m NetworkMonitor+networkMonitorGetDefault  = liftIO $ do+    result <- g_network_monitor_get_default+    checkUnexpectedReturnNULL "g_network_monitor_get_default" result+    result' <- (newObject NetworkMonitor) result+    return result'+++-- function g_io_scheduler_push_job+-- Args : [Arg {argName = "job_func", argType = TInterface "Gio" "IOSchedulerJobFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 1, argDestroy = 2, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "job_func", argType = TInterface "Gio" "IOSchedulerJobFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 1, argDestroy = 2, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_io_scheduler_push_job" g_io_scheduler_push_job :: +    FunPtr IOSchedulerJobFuncC ->           -- job_func : TInterface "Gio" "IOSchedulerJobFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    IO ()++{-# DEPRECATED ioSchedulerPushJob ["use #GThreadPool or g_task_run_in_thread()"]#-}+ioSchedulerPushJob ::+    (MonadIO m, CancellableK a) =>+    IOSchedulerJobFunc ->                   -- job_func+    Int32 ->                                -- io_priority+    Maybe (a) ->                            -- cancellable+    m ()+ioSchedulerPushJob job_func io_priority cancellable = liftIO $ do+    job_func' <- mkIOSchedulerJobFunc (iOSchedulerJobFuncWrapper Nothing job_func)+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    let user_data = castFunPtrToPtr job_func'+    let notify = safeFreeFunPtrPtr+    g_io_scheduler_push_job job_func' user_data notify io_priority maybeCancellable+    whenJust cancellable touchManagedPtr+    return ()+++-- function g_io_scheduler_cancel_all_jobs+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_io_scheduler_cancel_all_jobs" g_io_scheduler_cancel_all_jobs :: +    IO ()++{-# DEPRECATED ioSchedulerCancelAllJobs ["You should never call this function, since you don't","know how other libraries in your program might be making use of","gioscheduler."]#-}+ioSchedulerCancelAllJobs ::+    (MonadIO m) =>+    m ()+ioSchedulerCancelAllJobs  = liftIO $ do+    g_io_scheduler_cancel_all_jobs+    return ()+++-- function g_io_modules_scan_all_in_directory_with_scope+-- Args : [Arg {argName = "dirname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "scope", argType = TInterface "Gio" "IOModuleScope", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "dirname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "scope", argType = TInterface "Gio" "IOModuleScope", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_io_modules_scan_all_in_directory_with_scope" g_io_modules_scan_all_in_directory_with_scope :: +    CString ->                              -- dirname : TBasicType TUTF8+    Ptr IOModuleScope ->                    -- scope : TInterface "Gio" "IOModuleScope"+    IO ()+++ioModulesScanAllInDirectoryWithScope ::+    (MonadIO m) =>+    T.Text ->                               -- dirname+    IOModuleScope ->                        -- scope+    m ()+ioModulesScanAllInDirectoryWithScope dirname scope = liftIO $ do+    dirname' <- textToCString dirname+    let scope' = unsafeManagedPtrGetPtr scope+    g_io_modules_scan_all_in_directory_with_scope dirname' scope'+    touchManagedPtr scope+    freeMem dirname'+    return ()+++-- function g_io_modules_scan_all_in_directory+-- Args : [Arg {argName = "dirname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "dirname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_io_modules_scan_all_in_directory" g_io_modules_scan_all_in_directory :: +    CString ->                              -- dirname : TBasicType TUTF8+    IO ()+++ioModulesScanAllInDirectory ::+    (MonadIO m) =>+    T.Text ->                               -- dirname+    m ()+ioModulesScanAllInDirectory dirname = liftIO $ do+    dirname' <- textToCString dirname+    g_io_modules_scan_all_in_directory dirname'+    freeMem dirname'+    return ()+++-- function g_io_extension_point_register+-- Args : [Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "IOExtensionPoint"+-- throws : False+-- Skip return : False++foreign import ccall "g_io_extension_point_register" g_io_extension_point_register :: +    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr IOExtensionPoint)+++ioExtensionPointRegister ::+    (MonadIO m) =>+    T.Text ->                               -- name+    m IOExtensionPoint+ioExtensionPointRegister name = liftIO $ do+    name' <- textToCString name+    result <- g_io_extension_point_register name'+    checkUnexpectedReturnNULL "g_io_extension_point_register" result+    -- XXX Wrapping a foreign struct/union with no known destructor, leak?+    result' <- (\x -> IOExtensionPoint <$> newForeignPtr_ x) result+    freeMem name'+    return result'+++-- function g_io_extension_point_lookup+-- Args : [Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "IOExtensionPoint"+-- throws : False+-- Skip return : False++foreign import ccall "g_io_extension_point_lookup" g_io_extension_point_lookup :: +    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr IOExtensionPoint)+++ioExtensionPointLookup ::+    (MonadIO m) =>+    T.Text ->                               -- name+    m IOExtensionPoint+ioExtensionPointLookup name = liftIO $ do+    name' <- textToCString name+    result <- g_io_extension_point_lookup name'+    checkUnexpectedReturnNULL "g_io_extension_point_lookup" result+    -- XXX Wrapping a foreign struct/union with no known destructor, leak?+    result' <- (\x -> IOExtensionPoint <$> newForeignPtr_ x) result+    freeMem name'+    return result'+++-- function g_io_extension_point_implement+-- Args : [Arg {argName = "extension_point_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "extension_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "extension_point_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "extension_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "IOExtension"+-- throws : False+-- Skip return : False++foreign import ccall "g_io_extension_point_implement" g_io_extension_point_implement :: +    CString ->                              -- extension_point_name : TBasicType TUTF8+    CGType ->                               -- type : TBasicType TGType+    CString ->                              -- extension_name : TBasicType TUTF8+    Int32 ->                                -- priority : TBasicType TInt32+    IO (Ptr IOExtension)+++ioExtensionPointImplement ::+    (MonadIO m) =>+    T.Text ->                               -- extension_point_name+    GType ->                                -- type+    T.Text ->                               -- extension_name+    Int32 ->                                -- priority+    m IOExtension+ioExtensionPointImplement extension_point_name type_ extension_name priority = liftIO $ do+    extension_point_name' <- textToCString extension_point_name+    let type_' = gtypeToCGType type_+    extension_name' <- textToCString extension_name+    result <- g_io_extension_point_implement extension_point_name' type_' extension_name' priority+    checkUnexpectedReturnNULL "g_io_extension_point_implement" result+    -- XXX Wrapping a foreign struct/union with no known destructor, leak?+    result' <- (\x -> IOExtension <$> newForeignPtr_ x) result+    freeMem extension_point_name'+    freeMem extension_name'+    return result'+++-- function g_io_error_quark+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_io_error_quark" g_io_error_quark :: +    IO Word32+++ioErrorQuark ::+    (MonadIO m) =>+    m Word32+ioErrorQuark  = liftIO $ do+    result <- g_io_error_quark+    return result+++-- function g_io_error_from_errno+-- Args : [Arg {argName = "err_no", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "err_no", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "IOErrorEnum"+-- throws : False+-- Skip return : False++foreign import ccall "g_io_error_from_errno" g_io_error_from_errno :: +    Int32 ->                                -- err_no : TBasicType TInt32+    IO CUInt+++ioErrorFromErrno ::+    (MonadIO m) =>+    Int32 ->                                -- err_no+    m IOErrorEnum+ioErrorFromErrno err_no = liftIO $ do+    result <- g_io_error_from_errno err_no+    let result' = (toEnum . fromIntegral) result+    return result'+++-- function g_initable_newv+-- Args : [Arg {argName = "object_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_parameters", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameters", argType = TCArray False (-1) 1 (TInterface "GObject" "Parameter"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "n_parameters", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "object_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameters", argType = TCArray False (-1) 1 (TInterface "GObject" "Parameter"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GObject" "Object"+-- throws : True+-- Skip return : False++foreign import ccall "g_initable_newv" g_initable_newv :: +    CGType ->                               -- object_type : TBasicType TGType+    Word32 ->                               -- n_parameters : TBasicType TUInt32+    Ptr GObject.Parameter ->                -- parameters : TCArray False (-1) 1 (TInterface "GObject" "Parameter")+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr GObject.Object)+++initableNewv ::+    (MonadIO m, CancellableK a) =>+    GType ->                                -- object_type+    [GObject.Parameter] ->                  -- parameters+    Maybe (a) ->                            -- cancellable+    m GObject.Object+initableNewv object_type parameters cancellable = liftIO $ do+    let n_parameters = fromIntegral $ length parameters+    let object_type' = gtypeToCGType object_type+    let parameters' = map unsafeManagedPtrGetPtr parameters+    parameters'' <- packBlockArray 32 parameters'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_initable_newv object_type' n_parameters parameters'' maybeCancellable+        checkUnexpectedReturnNULL "g_initable_newv" result+        result' <- (wrapObject GObject.Object) result+        mapM_ touchManagedPtr parameters+        whenJust cancellable touchManagedPtr+        freeMem parameters''+        return result'+     ) (do+        freeMem parameters''+     )+++-- function g_icon_new_for_string+-- Args : [Arg {argName = "str", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "str", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Icon"+-- throws : True+-- Skip return : False++foreign import ccall "g_icon_new_for_string" g_icon_new_for_string :: +    CString ->                              -- str : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Icon)+++iconNewForString ::+    (MonadIO m) =>+    T.Text ->                               -- str+    m Icon+iconNewForString str = liftIO $ do+    str' <- textToCString str+    onException (do+        result <- propagateGError $ g_icon_new_for_string str'+        checkUnexpectedReturnNULL "g_icon_new_for_string" result+        result' <- (wrapObject Icon) result+        freeMem str'+        return result'+     ) (do+        freeMem str'+     )+++-- function g_icon_hash+-- Args : [Arg {argName = "icon", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "icon", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_icon_hash" g_icon_hash :: +    Ptr () ->                               -- icon : TBasicType TVoid+    IO Word32+++iconHash ::+    (MonadIO m) =>+    Ptr () ->                               -- icon+    m Word32+iconHash icon = liftIO $ do+    result <- g_icon_hash icon+    return result+++-- function g_icon_deserialize+-- Args : [Arg {argName = "value", argType = TVariant, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "value", argType = TVariant, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Icon"+-- throws : False+-- Skip return : False++foreign import ccall "g_icon_deserialize" g_icon_deserialize :: +    Ptr GVariant ->                         -- value : TVariant+    IO (Ptr Icon)+++iconDeserialize ::+    (MonadIO m) =>+    GVariant ->                             -- value+    m Icon+iconDeserialize value = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    result <- g_icon_deserialize value'+    checkUnexpectedReturnNULL "g_icon_deserialize" result+    result' <- (wrapObject Icon) result+    return result'+++-- function g_file_parse_name+-- Args : [Arg {argName = "parse_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "parse_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "File"+-- throws : False+-- Skip return : False++foreign import ccall "g_file_parse_name" g_file_parse_name :: +    CString ->                              -- parse_name : TBasicType TUTF8+    IO (Ptr File)+++fileParseName ::+    (MonadIO m) =>+    T.Text ->                               -- parse_name+    m File+fileParseName parse_name = liftIO $ do+    parse_name' <- textToCString parse_name+    result <- g_file_parse_name parse_name'+    checkUnexpectedReturnNULL "g_file_parse_name" result+    result' <- (wrapObject File) result+    freeMem parse_name'+    return result'+++-- function g_file_new_tmp+-- Args : [Arg {argName = "tmpl", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iostream", argType = TInterface "Gio" "FileIOStream", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "tmpl", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "File"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_new_tmp" g_file_new_tmp :: +    CString ->                              -- tmpl : TBasicType TFileName+    Ptr (Ptr FileIOStream) ->               -- iostream : TInterface "Gio" "FileIOStream"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr File)+++fileNewTmp ::+    (MonadIO m) =>+    Maybe ([Char]) ->                       -- tmpl+    m (File,FileIOStream)+fileNewTmp tmpl = liftIO $ do+    maybeTmpl <- case tmpl of+        Nothing -> return nullPtr+        Just jTmpl -> do+            jTmpl' <- stringToCString jTmpl+            return jTmpl'+    iostream <- allocMem :: IO (Ptr (Ptr FileIOStream))+    onException (do+        result <- propagateGError $ g_file_new_tmp maybeTmpl iostream+        checkUnexpectedReturnNULL "g_file_new_tmp" result+        result' <- (wrapObject File) result+        iostream' <- peek iostream+        iostream'' <- (wrapObject FileIOStream) iostream'+        freeMem maybeTmpl+        freeMem iostream+        return (result', iostream'')+     ) (do+        freeMem maybeTmpl+        freeMem iostream+     )+++-- function g_file_new_for_uri+-- Args : [Arg {argName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "File"+-- throws : False+-- Skip return : False++foreign import ccall "g_file_new_for_uri" g_file_new_for_uri :: +    CString ->                              -- uri : TBasicType TUTF8+    IO (Ptr File)+++fileNewForUri ::+    (MonadIO m) =>+    T.Text ->                               -- uri+    m File+fileNewForUri uri = liftIO $ do+    uri' <- textToCString uri+    result <- g_file_new_for_uri uri'+    checkUnexpectedReturnNULL "g_file_new_for_uri" result+    result' <- (wrapObject File) result+    freeMem uri'+    return result'+++-- function g_file_new_for_path+-- Args : [Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "File"+-- throws : False+-- Skip return : False++foreign import ccall "g_file_new_for_path" g_file_new_for_path :: +    CString ->                              -- path : TBasicType TUTF8+    IO (Ptr File)+++fileNewForPath ::+    (MonadIO m) =>+    T.Text ->                               -- path+    m File+fileNewForPath path = liftIO $ do+    path' <- textToCString path+    result <- g_file_new_for_path path'+    checkUnexpectedReturnNULL "g_file_new_for_path" result+    result' <- (wrapObject File) result+    freeMem path'+    return result'+++-- function g_file_new_for_commandline_arg_and_cwd+-- Args : [Arg {argName = "arg", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cwd", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "arg", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cwd", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "File"+-- throws : False+-- Skip return : False++foreign import ccall "g_file_new_for_commandline_arg_and_cwd" g_file_new_for_commandline_arg_and_cwd :: +    CString ->                              -- arg : TBasicType TUTF8+    CString ->                              -- cwd : TBasicType TUTF8+    IO (Ptr File)+++fileNewForCommandlineArgAndCwd ::+    (MonadIO m) =>+    T.Text ->                               -- arg+    T.Text ->                               -- cwd+    m File+fileNewForCommandlineArgAndCwd arg cwd = liftIO $ do+    arg' <- textToCString arg+    cwd' <- textToCString cwd+    result <- g_file_new_for_commandline_arg_and_cwd arg' cwd'+    checkUnexpectedReturnNULL "g_file_new_for_commandline_arg_and_cwd" result+    result' <- (wrapObject File) result+    freeMem arg'+    freeMem cwd'+    return result'+++-- function g_file_new_for_commandline_arg+-- Args : [Arg {argName = "arg", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "arg", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "File"+-- throws : False+-- Skip return : False++foreign import ccall "g_file_new_for_commandline_arg" g_file_new_for_commandline_arg :: +    CString ->                              -- arg : TBasicType TUTF8+    IO (Ptr File)+++fileNewForCommandlineArg ::+    (MonadIO m) =>+    T.Text ->                               -- arg+    m File+fileNewForCommandlineArg arg = liftIO $ do+    arg' <- textToCString arg+    result <- g_file_new_for_commandline_arg arg'+    checkUnexpectedReturnNULL "g_file_new_for_commandline_arg" result+    result' <- (wrapObject File) result+    freeMem arg'+    return result'+++-- function g_dbus_is_unique_name+-- Args : [Arg {argName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_is_unique_name" g_dbus_is_unique_name :: +    CString ->                              -- string : TBasicType TUTF8+    IO CInt+++dbusIsUniqueName ::+    (MonadIO m) =>+    T.Text ->                               -- string+    m Bool+dbusIsUniqueName string = liftIO $ do+    string' <- textToCString string+    result <- g_dbus_is_unique_name string'+    let result' = (/= 0) result+    freeMem string'+    return result'+++-- function g_dbus_is_supported_address+-- Args : [Arg {argName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_is_supported_address" g_dbus_is_supported_address :: +    CString ->                              -- string : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++dbusIsSupportedAddress ::+    (MonadIO m) =>+    T.Text ->                               -- string+    m ()+dbusIsSupportedAddress string = liftIO $ do+    string' <- textToCString string+    onException (do+        _ <- propagateGError $ g_dbus_is_supported_address string'+        freeMem string'+        return ()+     ) (do+        freeMem string'+     )+++-- function g_dbus_is_name+-- Args : [Arg {argName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_is_name" g_dbus_is_name :: +    CString ->                              -- string : TBasicType TUTF8+    IO CInt+++dbusIsName ::+    (MonadIO m) =>+    T.Text ->                               -- string+    m Bool+dbusIsName string = liftIO $ do+    string' <- textToCString string+    result <- g_dbus_is_name string'+    let result' = (/= 0) result+    freeMem string'+    return result'+++-- function g_dbus_is_member_name+-- Args : [Arg {argName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_is_member_name" g_dbus_is_member_name :: +    CString ->                              -- string : TBasicType TUTF8+    IO CInt+++dbusIsMemberName ::+    (MonadIO m) =>+    T.Text ->                               -- string+    m Bool+dbusIsMemberName string = liftIO $ do+    string' <- textToCString string+    result <- g_dbus_is_member_name string'+    let result' = (/= 0) result+    freeMem string'+    return result'+++-- function g_dbus_is_interface_name+-- Args : [Arg {argName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_is_interface_name" g_dbus_is_interface_name :: +    CString ->                              -- string : TBasicType TUTF8+    IO CInt+++dbusIsInterfaceName ::+    (MonadIO m) =>+    T.Text ->                               -- string+    m Bool+dbusIsInterfaceName string = liftIO $ do+    string' <- textToCString string+    result <- g_dbus_is_interface_name string'+    let result' = (/= 0) result+    freeMem string'+    return result'+++-- function g_dbus_is_guid+-- Args : [Arg {argName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_is_guid" g_dbus_is_guid :: +    CString ->                              -- string : TBasicType TUTF8+    IO CInt+++dbusIsGuid ::+    (MonadIO m) =>+    T.Text ->                               -- string+    m Bool+dbusIsGuid string = liftIO $ do+    string' <- textToCString string+    result <- g_dbus_is_guid string'+    let result' = (/= 0) result+    freeMem string'+    return result'+++-- function g_dbus_is_address+-- Args : [Arg {argName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_is_address" g_dbus_is_address :: +    CString ->                              -- string : TBasicType TUTF8+    IO CInt+++dbusIsAddress ::+    (MonadIO m) =>+    T.Text ->                               -- string+    m Bool+dbusIsAddress string = liftIO $ do+    string' <- textToCString string+    result <- g_dbus_is_address string'+    let result' = (/= 0) result+    freeMem string'+    return result'+++-- function g_dbus_gvariant_to_gvalue+-- Args : [Arg {argName = "value", argType = TVariant, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "out_gvalue", argType = TInterface "GObject" "Value", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "value", argType = TVariant, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_gvariant_to_gvalue" g_dbus_gvariant_to_gvalue :: +    Ptr GVariant ->                         -- value : TVariant+    Ptr GValue ->                           -- out_gvalue : TInterface "GObject" "Value"+    IO ()+++dbusGvariantToGvalue ::+    (MonadIO m) =>+    GVariant ->                             -- value+    m (GValue)+dbusGvariantToGvalue value = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    out_gvalue <- callocBoxedBytes 24 :: IO (Ptr GValue)+    g_dbus_gvariant_to_gvalue value' out_gvalue+    out_gvalue' <- (wrapBoxed GValue) out_gvalue+    return out_gvalue'+++-- function g_dbus_gvalue_to_gvariant+-- Args : [Arg {argName = "gvalue", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "GLib" "VariantType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "gvalue", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "GLib" "VariantType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TVariant+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_gvalue_to_gvariant" g_dbus_gvalue_to_gvariant :: +    Ptr GValue ->                           -- gvalue : TInterface "GObject" "Value"+    Ptr GLib.VariantType ->                 -- type : TInterface "GLib" "VariantType"+    IO (Ptr GVariant)+++dbusGvalueToGvariant ::+    (MonadIO m) =>+    GValue ->                               -- gvalue+    GLib.VariantType ->                     -- type+    m GVariant+dbusGvalueToGvariant gvalue type_ = liftIO $ do+    let gvalue' = unsafeManagedPtrGetPtr gvalue+    let type_' = unsafeManagedPtrGetPtr type_+    result <- g_dbus_gvalue_to_gvariant gvalue' type_'+    checkUnexpectedReturnNULL "g_dbus_gvalue_to_gvariant" result+    result' <- wrapGVariantPtr result+    touchManagedPtr gvalue+    touchManagedPtr type_+    return result'+++-- function g_dbus_generate_guid+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_generate_guid" g_dbus_generate_guid :: +    IO CString+++dbusGenerateGuid ::+    (MonadIO m) =>+    m T.Text+dbusGenerateGuid  = liftIO $ do+    result <- g_dbus_generate_guid+    checkUnexpectedReturnNULL "g_dbus_generate_guid" result+    result' <- cstringToText result+    freeMem result+    return result'+++-- function g_dbus_error_unregister_error+-- Args : [Arg {argName = "error_domain", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "error_code", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "dbus_error_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "error_domain", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "error_code", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "dbus_error_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_error_unregister_error" g_dbus_error_unregister_error :: +    Word32 ->                               -- error_domain : TBasicType TUInt32+    Int32 ->                                -- error_code : TBasicType TInt32+    CString ->                              -- dbus_error_name : TBasicType TUTF8+    IO CInt+++dbusErrorUnregisterError ::+    (MonadIO m) =>+    Word32 ->                               -- error_domain+    Int32 ->                                -- error_code+    T.Text ->                               -- dbus_error_name+    m Bool+dbusErrorUnregisterError error_domain error_code dbus_error_name = liftIO $ do+    dbus_error_name' <- textToCString dbus_error_name+    result <- g_dbus_error_unregister_error error_domain error_code dbus_error_name'+    let result' = (/= 0) result+    freeMem dbus_error_name'+    return result'+++-- function g_dbus_error_strip_remote_error+-- Args : [Arg {argName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_error_strip_remote_error" g_dbus_error_strip_remote_error :: +    Ptr GError ->                           -- error : TError+    IO CInt+++dbusErrorStripRemoteError ::+    (MonadIO m) =>+    GError ->                               -- error+    m Bool+dbusErrorStripRemoteError error_ = liftIO $ do+    let error_' = unsafeManagedPtrGetPtr error_+    result <- g_dbus_error_strip_remote_error error_'+    let result' = (/= 0) result+    touchManagedPtr error_+    return result'+++-- function g_dbus_error_register_error_domain+-- Args : [Arg {argName = "error_domain_quark_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "quark_volatile", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "entries", argType = TInterface "Gio" "DBusErrorEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "num_entries", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "error_domain_quark_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "quark_volatile", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "entries", argType = TInterface "Gio" "DBusErrorEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "num_entries", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_error_register_error_domain" g_dbus_error_register_error_domain :: +    CString ->                              -- error_domain_quark_name : TBasicType TUTF8+    Word64 ->                               -- quark_volatile : TBasicType TUInt64+    Ptr DBusErrorEntry ->                   -- entries : TInterface "Gio" "DBusErrorEntry"+    Word32 ->                               -- num_entries : TBasicType TUInt32+    IO ()+++dbusErrorRegisterErrorDomain ::+    (MonadIO m) =>+    T.Text ->                               -- error_domain_quark_name+    Word64 ->                               -- quark_volatile+    DBusErrorEntry ->                       -- entries+    Word32 ->                               -- num_entries+    m ()+dbusErrorRegisterErrorDomain error_domain_quark_name quark_volatile entries num_entries = liftIO $ do+    error_domain_quark_name' <- textToCString error_domain_quark_name+    let entries' = unsafeManagedPtrGetPtr entries+    g_dbus_error_register_error_domain error_domain_quark_name' quark_volatile entries' num_entries+    touchManagedPtr entries+    freeMem error_domain_quark_name'+    return ()+++-- function g_dbus_error_register_error+-- Args : [Arg {argName = "error_domain", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "error_code", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "dbus_error_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "error_domain", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "error_code", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "dbus_error_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_error_register_error" g_dbus_error_register_error :: +    Word32 ->                               -- error_domain : TBasicType TUInt32+    Int32 ->                                -- error_code : TBasicType TInt32+    CString ->                              -- dbus_error_name : TBasicType TUTF8+    IO CInt+++dbusErrorRegisterError ::+    (MonadIO m) =>+    Word32 ->                               -- error_domain+    Int32 ->                                -- error_code+    T.Text ->                               -- dbus_error_name+    m Bool+dbusErrorRegisterError error_domain error_code dbus_error_name = liftIO $ do+    dbus_error_name' <- textToCString dbus_error_name+    result <- g_dbus_error_register_error error_domain error_code dbus_error_name'+    let result' = (/= 0) result+    freeMem dbus_error_name'+    return result'+++-- function g_dbus_error_quark+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_error_quark" g_dbus_error_quark :: +    IO Word32+++dbusErrorQuark ::+    (MonadIO m) =>+    m Word32+dbusErrorQuark  = liftIO $ do+    result <- g_dbus_error_quark+    return result+++-- function g_dbus_error_new_for_dbus_error+-- Args : [Arg {argName = "dbus_error_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "dbus_error_message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "dbus_error_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "dbus_error_message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TError+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_error_new_for_dbus_error" g_dbus_error_new_for_dbus_error :: +    CString ->                              -- dbus_error_name : TBasicType TUTF8+    CString ->                              -- dbus_error_message : TBasicType TUTF8+    IO (Ptr GError)+++dbusErrorNewForDbusError ::+    (MonadIO m) =>+    T.Text ->                               -- dbus_error_name+    T.Text ->                               -- dbus_error_message+    m GError+dbusErrorNewForDbusError dbus_error_name dbus_error_message = liftIO $ do+    dbus_error_name' <- textToCString dbus_error_name+    dbus_error_message' <- textToCString dbus_error_message+    result <- g_dbus_error_new_for_dbus_error dbus_error_name' dbus_error_message'+    checkUnexpectedReturnNULL "g_dbus_error_new_for_dbus_error" result+    result' <- (wrapBoxed GError) result+    freeMem dbus_error_name'+    freeMem dbus_error_message'+    return result'+++-- function g_dbus_error_is_remote_error+-- Args : [Arg {argName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_error_is_remote_error" g_dbus_error_is_remote_error :: +    Ptr GError ->                           -- error : TError+    IO CInt+++dbusErrorIsRemoteError ::+    (MonadIO m) =>+    GError ->                               -- error+    m Bool+dbusErrorIsRemoteError error_ = liftIO $ do+    let error_' = unsafeManagedPtrGetPtr error_+    result <- g_dbus_error_is_remote_error error_'+    let result' = (/= 0) result+    touchManagedPtr error_+    return result'+++-- function g_dbus_error_get_remote_error+-- Args : [Arg {argName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_error_get_remote_error" g_dbus_error_get_remote_error :: +    Ptr GError ->                           -- error : TError+    IO CString+++dbusErrorGetRemoteError ::+    (MonadIO m) =>+    GError ->                               -- error+    m T.Text+dbusErrorGetRemoteError error_ = liftIO $ do+    let error_' = unsafeManagedPtrGetPtr error_+    result <- g_dbus_error_get_remote_error error_'+    checkUnexpectedReturnNULL "g_dbus_error_get_remote_error" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr error_+    return result'+++-- function g_dbus_error_encode_gerror+-- Args : [Arg {argName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_error_encode_gerror" g_dbus_error_encode_gerror :: +    Ptr GError ->                           -- error : TError+    IO CString+++dbusErrorEncodeGerror ::+    (MonadIO m) =>+    GError ->                               -- error+    m T.Text+dbusErrorEncodeGerror error_ = liftIO $ do+    let error_' = unsafeManagedPtrGetPtr error_+    result <- g_dbus_error_encode_gerror error_'+    checkUnexpectedReturnNULL "g_dbus_error_encode_gerror" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr error_+    return result'+++-- function g_dbus_annotation_info_lookup+-- Args : [Arg {argName = "annotations", argType = TCArray True (-1) (-1) (TInterface "Gio" "DBusAnnotationInfo"), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "annotations", argType = TCArray True (-1) (-1) (TInterface "Gio" "DBusAnnotationInfo"), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_annotation_info_lookup" g_dbus_annotation_info_lookup :: +    Ptr (Ptr DBusAnnotationInfo) ->         -- annotations : TCArray True (-1) (-1) (TInterface "Gio" "DBusAnnotationInfo")+    CString ->                              -- name : TBasicType TUTF8+    IO CString+++dbusAnnotationInfoLookup ::+    (MonadIO m) =>+    Maybe ([DBusAnnotationInfo]) ->         -- annotations+    T.Text ->                               -- name+    m T.Text+dbusAnnotationInfoLookup annotations name = liftIO $ do+    maybeAnnotations <- case annotations of+        Nothing -> return nullPtr+        Just jAnnotations -> do+            let jAnnotations' = map unsafeManagedPtrGetPtr jAnnotations+            jAnnotations'' <- packZeroTerminatedPtrArray jAnnotations'+            return jAnnotations''+    name' <- textToCString name+    result <- g_dbus_annotation_info_lookup maybeAnnotations name'+    checkUnexpectedReturnNULL "g_dbus_annotation_info_lookup" result+    result' <- cstringToText result+    whenJust annotations (mapM_ touchManagedPtr)+    freeMem maybeAnnotations+    freeMem name'+    return result'+++-- function g_dbus_address_get_stream_sync+-- Args : [Arg {argName = "address", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "out_guid", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "address", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "out_guid", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "IOStream"+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_address_get_stream_sync" g_dbus_address_get_stream_sync :: +    CString ->                              -- address : TBasicType TUTF8+    CString ->                              -- out_guid : TBasicType TUTF8+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr IOStream)+++dbusAddressGetStreamSync ::+    (MonadIO m, CancellableK a) =>+    T.Text ->                               -- address+    T.Text ->                               -- out_guid+    Maybe (a) ->                            -- cancellable+    m IOStream+dbusAddressGetStreamSync address out_guid cancellable = liftIO $ do+    address' <- textToCString address+    out_guid' <- textToCString out_guid+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_dbus_address_get_stream_sync address' out_guid' maybeCancellable+        checkUnexpectedReturnNULL "g_dbus_address_get_stream_sync" result+        result' <- (wrapObject IOStream) result+        whenJust cancellable touchManagedPtr+        freeMem address'+        freeMem out_guid'+        return result'+     ) (do+        freeMem address'+        freeMem out_guid'+     )+++-- function g_dbus_address_get_stream_finish+-- Args : [Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "out_guid", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "out_guid", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "IOStream"+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_address_get_stream_finish" g_dbus_address_get_stream_finish :: +    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    CString ->                              -- out_guid : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr IOStream)+++dbusAddressGetStreamFinish ::+    (MonadIO m, AsyncResultK a) =>+    a ->                                    -- res+    T.Text ->                               -- out_guid+    m IOStream+dbusAddressGetStreamFinish res out_guid = liftIO $ do+    let res' = unsafeManagedPtrCastPtr res+    out_guid' <- textToCString out_guid+    onException (do+        result <- propagateGError $ g_dbus_address_get_stream_finish res' out_guid'+        checkUnexpectedReturnNULL "g_dbus_address_get_stream_finish" result+        result' <- (wrapObject IOStream) result+        touchManagedPtr res+        freeMem out_guid'+        return result'+     ) (do+        freeMem out_guid'+     )+++-- function g_dbus_address_get_stream+-- Args : [Arg {argName = "address", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "address", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_address_get_stream" g_dbus_address_get_stream :: +    CString ->                              -- address : TBasicType TUTF8+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++dbusAddressGetStream ::+    (MonadIO m, CancellableK a) =>+    T.Text ->                               -- address+    Maybe (a) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+dbusAddressGetStream address cancellable callback = liftIO $ do+    address' <- textToCString address+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_dbus_address_get_stream address' maybeCancellable maybeCallback user_data+    whenJust cancellable touchManagedPtr+    freeMem address'+    return ()+++-- function g_dbus_address_get_for_bus_sync+-- Args : [Arg {argName = "bus_type", argType = TInterface "Gio" "BusType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "bus_type", argType = TInterface "Gio" "BusType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_address_get_for_bus_sync" g_dbus_address_get_for_bus_sync :: +    CUInt ->                                -- bus_type : TInterface "Gio" "BusType"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CString+++dbusAddressGetForBusSync ::+    (MonadIO m, CancellableK a) =>+    BusType ->                              -- bus_type+    Maybe (a) ->                            -- cancellable+    m T.Text+dbusAddressGetForBusSync bus_type cancellable = liftIO $ do+    let bus_type' = (fromIntegral . fromEnum) bus_type+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_dbus_address_get_for_bus_sync bus_type' maybeCancellable+        checkUnexpectedReturnNULL "g_dbus_address_get_for_bus_sync" result+        result' <- cstringToText result+        freeMem result+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )+++-- function g_dbus_address_escape_value+-- Args : [Arg {argName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_address_escape_value" g_dbus_address_escape_value :: +    CString ->                              -- string : TBasicType TUTF8+    IO CString+++dbusAddressEscapeValue ::+    (MonadIO m) =>+    T.Text ->                               -- string+    m T.Text+dbusAddressEscapeValue string = liftIO $ do+    string' <- textToCString string+    result <- g_dbus_address_escape_value string'+    checkUnexpectedReturnNULL "g_dbus_address_escape_value" result+    result' <- cstringToText result+    freeMem result+    freeMem string'+    return result'+++-- function g_content_types_get_registered+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TGList (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_content_types_get_registered" g_content_types_get_registered :: +    IO (Ptr (GList CString))+++contentTypesGetRegistered ::+    (MonadIO m) =>+    m [T.Text]+contentTypesGetRegistered  = liftIO $ do+    result <- g_content_types_get_registered+    checkUnexpectedReturnNULL "g_content_types_get_registered" result+    result' <- unpackGList result+    result'' <- mapM cstringToText result'+    mapGList freeMem result+    g_list_free result+    return result''+++-- function g_content_type_is_unknown+-- Args : [Arg {argName = "type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_content_type_is_unknown" g_content_type_is_unknown :: +    CString ->                              -- type : TBasicType TUTF8+    IO CInt+++contentTypeIsUnknown ::+    (MonadIO m) =>+    T.Text ->                               -- type+    m Bool+contentTypeIsUnknown type_ = liftIO $ do+    type_' <- textToCString type_+    result <- g_content_type_is_unknown type_'+    let result' = (/= 0) result+    freeMem type_'+    return result'+++-- function g_content_type_is_a+-- Args : [Arg {argName = "type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "supertype", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "supertype", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_content_type_is_a" g_content_type_is_a :: +    CString ->                              -- type : TBasicType TUTF8+    CString ->                              -- supertype : TBasicType TUTF8+    IO CInt+++contentTypeIsA ::+    (MonadIO m) =>+    T.Text ->                               -- type+    T.Text ->                               -- supertype+    m Bool+contentTypeIsA type_ supertype = liftIO $ do+    type_' <- textToCString type_+    supertype' <- textToCString supertype+    result <- g_content_type_is_a type_' supertype'+    let result' = (/= 0) result+    freeMem type_'+    freeMem supertype'+    return result'+++-- function g_content_type_guess_for_tree+-- Args : [Arg {argName = "root", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "root", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_content_type_guess_for_tree" g_content_type_guess_for_tree :: +    Ptr File ->                             -- root : TInterface "Gio" "File"+    IO (Ptr CString)+++contentTypeGuessForTree ::+    (MonadIO m, FileK a) =>+    a ->                                    -- root+    m [T.Text]+contentTypeGuessForTree root = liftIO $ do+    let root' = unsafeManagedPtrCastPtr root+    result <- g_content_type_guess_for_tree root'+    checkUnexpectedReturnNULL "g_content_type_guess_for_tree" result+    result' <- unpackZeroTerminatedUTF8CArray result+    mapZeroTerminatedCArray freeMem result+    freeMem result+    touchManagedPtr root+    return result'+++-- function g_content_type_guess+-- Args : [Arg {argName = "filename", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "data", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "data_size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result_uncertain", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : [Arg {argName = "data_size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "filename", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "data", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_content_type_guess" g_content_type_guess :: +    CString ->                              -- filename : TBasicType TUTF8+    Ptr Word8 ->                            -- data : TCArray False (-1) 2 (TBasicType TUInt8)+    Word64 ->                               -- data_size : TBasicType TUInt64+    Ptr CInt ->                             -- result_uncertain : TBasicType TBoolean+    IO CString+++contentTypeGuess ::+    (MonadIO m) =>+    Maybe (T.Text) ->                       -- filename+    Maybe (ByteString) ->                   -- data+    m (T.Text,Bool)+contentTypeGuess filename data_ = liftIO $ do+    let data_size = case data_ of+            Nothing -> 0+            Just jData_ -> fromIntegral $ B.length jData_+    maybeFilename <- case filename of+        Nothing -> return nullPtr+        Just jFilename -> do+            jFilename' <- textToCString jFilename+            return jFilename'+    maybeData_ <- case data_ of+        Nothing -> return nullPtr+        Just jData_ -> do+            jData_' <- packByteString jData_+            return jData_'+    result_uncertain <- allocMem :: IO (Ptr CInt)+    result <- g_content_type_guess maybeFilename maybeData_ data_size result_uncertain+    checkUnexpectedReturnNULL "g_content_type_guess" result+    result' <- cstringToText result+    freeMem result+    result_uncertain' <- peek result_uncertain+    let result_uncertain'' = (/= 0) result_uncertain'+    freeMem maybeFilename+    freeMem maybeData_+    freeMem result_uncertain+    return (result', result_uncertain'')+++-- function g_content_type_get_symbolic_icon+-- Args : [Arg {argName = "type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Icon"+-- throws : False+-- Skip return : False++foreign import ccall "g_content_type_get_symbolic_icon" g_content_type_get_symbolic_icon :: +    CString ->                              -- type : TBasicType TUTF8+    IO (Ptr Icon)+++contentTypeGetSymbolicIcon ::+    (MonadIO m) =>+    T.Text ->                               -- type+    m Icon+contentTypeGetSymbolicIcon type_ = liftIO $ do+    type_' <- textToCString type_+    result <- g_content_type_get_symbolic_icon type_'+    checkUnexpectedReturnNULL "g_content_type_get_symbolic_icon" result+    result' <- (wrapObject Icon) result+    freeMem type_'+    return result'+++-- function g_content_type_get_mime_type+-- Args : [Arg {argName = "type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_content_type_get_mime_type" g_content_type_get_mime_type :: +    CString ->                              -- type : TBasicType TUTF8+    IO CString+++contentTypeGetMimeType ::+    (MonadIO m) =>+    T.Text ->                               -- type+    m T.Text+contentTypeGetMimeType type_ = liftIO $ do+    type_' <- textToCString type_+    result <- g_content_type_get_mime_type type_'+    checkUnexpectedReturnNULL "g_content_type_get_mime_type" result+    result' <- cstringToText result+    freeMem result+    freeMem type_'+    return result'+++-- function g_content_type_get_icon+-- Args : [Arg {argName = "type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Icon"+-- throws : False+-- Skip return : False++foreign import ccall "g_content_type_get_icon" g_content_type_get_icon :: +    CString ->                              -- type : TBasicType TUTF8+    IO (Ptr Icon)+++contentTypeGetIcon ::+    (MonadIO m) =>+    T.Text ->                               -- type+    m Icon+contentTypeGetIcon type_ = liftIO $ do+    type_' <- textToCString type_+    result <- g_content_type_get_icon type_'+    checkUnexpectedReturnNULL "g_content_type_get_icon" result+    result' <- (wrapObject Icon) result+    freeMem type_'+    return result'+++-- function g_content_type_get_generic_icon_name+-- Args : [Arg {argName = "type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_content_type_get_generic_icon_name" g_content_type_get_generic_icon_name :: +    CString ->                              -- type : TBasicType TUTF8+    IO CString+++contentTypeGetGenericIconName ::+    (MonadIO m) =>+    T.Text ->                               -- type+    m T.Text+contentTypeGetGenericIconName type_ = liftIO $ do+    type_' <- textToCString type_+    result <- g_content_type_get_generic_icon_name type_'+    checkUnexpectedReturnNULL "g_content_type_get_generic_icon_name" result+    result' <- cstringToText result+    freeMem result+    freeMem type_'+    return result'+++-- function g_content_type_get_description+-- Args : [Arg {argName = "type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_content_type_get_description" g_content_type_get_description :: +    CString ->                              -- type : TBasicType TUTF8+    IO CString+++contentTypeGetDescription ::+    (MonadIO m) =>+    T.Text ->                               -- type+    m T.Text+contentTypeGetDescription type_ = liftIO $ do+    type_' <- textToCString type_+    result <- g_content_type_get_description type_'+    checkUnexpectedReturnNULL "g_content_type_get_description" result+    result' <- cstringToText result+    freeMem result+    freeMem type_'+    return result'+++-- function g_content_type_from_mime_type+-- Args : [Arg {argName = "mime_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "mime_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_content_type_from_mime_type" g_content_type_from_mime_type :: +    CString ->                              -- mime_type : TBasicType TUTF8+    IO CString+++contentTypeFromMimeType ::+    (MonadIO m) =>+    T.Text ->                               -- mime_type+    m T.Text+contentTypeFromMimeType mime_type = liftIO $ do+    mime_type' <- textToCString mime_type+    result <- g_content_type_from_mime_type mime_type'+    checkUnexpectedReturnNULL "g_content_type_from_mime_type" result+    result' <- cstringToText result+    freeMem result+    freeMem mime_type'+    return result'+++-- function g_content_type_equals+-- Args : [Arg {argName = "type1", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type2", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "type1", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type2", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_content_type_equals" g_content_type_equals :: +    CString ->                              -- type1 : TBasicType TUTF8+    CString ->                              -- type2 : TBasicType TUTF8+    IO CInt+++contentTypeEquals ::+    (MonadIO m) =>+    T.Text ->                               -- type1+    T.Text ->                               -- type2+    m Bool+contentTypeEquals type1 type2 = liftIO $ do+    type1' <- textToCString type1+    type2' <- textToCString type2+    result <- g_content_type_equals type1' type2'+    let result' = (/= 0) result+    freeMem type1'+    freeMem type2'+    return result'+++-- function g_content_type_can_be_executable+-- Args : [Arg {argName = "type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_content_type_can_be_executable" g_content_type_can_be_executable :: +    CString ->                              -- type : TBasicType TUTF8+    IO CInt+++contentTypeCanBeExecutable ::+    (MonadIO m) =>+    T.Text ->                               -- type+    m Bool+contentTypeCanBeExecutable type_ = liftIO $ do+    type_' <- textToCString type_+    result <- g_content_type_can_be_executable type_'+    let result' = (/= 0) result+    freeMem type_'+    return result'+++-- function g_bus_watch_name_on_connection_with_closures+-- Args : [Arg {argName = "connection", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "BusNameWatcherFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name_appeared_closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name_vanished_closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "connection", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "BusNameWatcherFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name_appeared_closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name_vanished_closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_bus_watch_name_on_connection_with_closures" g_bus_watch_name_on_connection_with_closures :: +    Ptr DBusConnection ->                   -- connection : TInterface "Gio" "DBusConnection"+    CString ->                              -- name : TBasicType TUTF8+    CUInt ->                                -- flags : TInterface "Gio" "BusNameWatcherFlags"+    Ptr Closure ->                          -- name_appeared_closure : TInterface "GObject" "Closure"+    Ptr Closure ->                          -- name_vanished_closure : TInterface "GObject" "Closure"+    IO Word32+++busWatchNameOnConnection ::+    (MonadIO m, DBusConnectionK a) =>+    a ->                                    -- connection+    T.Text ->                               -- name+    [BusNameWatcherFlags] ->                -- flags+    Maybe (Closure) ->                      -- name_appeared_closure+    Maybe (Closure) ->                      -- name_vanished_closure+    m Word32+busWatchNameOnConnection connection name flags name_appeared_closure name_vanished_closure = liftIO $ do+    let connection' = unsafeManagedPtrCastPtr connection+    name' <- textToCString name+    let flags' = gflagsToWord flags+    maybeName_appeared_closure <- case name_appeared_closure of+        Nothing -> return nullPtr+        Just jName_appeared_closure -> do+            let jName_appeared_closure' = unsafeManagedPtrGetPtr jName_appeared_closure+            return jName_appeared_closure'+    maybeName_vanished_closure <- case name_vanished_closure of+        Nothing -> return nullPtr+        Just jName_vanished_closure -> do+            let jName_vanished_closure' = unsafeManagedPtrGetPtr jName_vanished_closure+            return jName_vanished_closure'+    result <- g_bus_watch_name_on_connection_with_closures connection' name' flags' maybeName_appeared_closure maybeName_vanished_closure+    touchManagedPtr connection+    whenJust name_appeared_closure touchManagedPtr+    whenJust name_vanished_closure touchManagedPtr+    freeMem name'+    return result+++-- function g_bus_watch_name_with_closures+-- Args : [Arg {argName = "bus_type", argType = TInterface "Gio" "BusType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "BusNameWatcherFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name_appeared_closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name_vanished_closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "bus_type", argType = TInterface "Gio" "BusType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "BusNameWatcherFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name_appeared_closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name_vanished_closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_bus_watch_name_with_closures" g_bus_watch_name_with_closures :: +    CUInt ->                                -- bus_type : TInterface "Gio" "BusType"+    CString ->                              -- name : TBasicType TUTF8+    CUInt ->                                -- flags : TInterface "Gio" "BusNameWatcherFlags"+    Ptr Closure ->                          -- name_appeared_closure : TInterface "GObject" "Closure"+    Ptr Closure ->                          -- name_vanished_closure : TInterface "GObject" "Closure"+    IO Word32+++busWatchName ::+    (MonadIO m) =>+    BusType ->                              -- bus_type+    T.Text ->                               -- name+    [BusNameWatcherFlags] ->                -- flags+    Maybe (Closure) ->                      -- name_appeared_closure+    Maybe (Closure) ->                      -- name_vanished_closure+    m Word32+busWatchName bus_type name flags name_appeared_closure name_vanished_closure = liftIO $ do+    let bus_type' = (fromIntegral . fromEnum) bus_type+    name' <- textToCString name+    let flags' = gflagsToWord flags+    maybeName_appeared_closure <- case name_appeared_closure of+        Nothing -> return nullPtr+        Just jName_appeared_closure -> do+            let jName_appeared_closure' = unsafeManagedPtrGetPtr jName_appeared_closure+            return jName_appeared_closure'+    maybeName_vanished_closure <- case name_vanished_closure of+        Nothing -> return nullPtr+        Just jName_vanished_closure -> do+            let jName_vanished_closure' = unsafeManagedPtrGetPtr jName_vanished_closure+            return jName_vanished_closure'+    result <- g_bus_watch_name_with_closures bus_type' name' flags' maybeName_appeared_closure maybeName_vanished_closure+    whenJust name_appeared_closure touchManagedPtr+    whenJust name_vanished_closure touchManagedPtr+    freeMem name'+    return result+++-- function g_bus_unwatch_name+-- Args : [Arg {argName = "watcher_id", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "watcher_id", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_bus_unwatch_name" g_bus_unwatch_name :: +    Word32 ->                               -- watcher_id : TBasicType TUInt32+    IO ()+++busUnwatchName ::+    (MonadIO m) =>+    Word32 ->                               -- watcher_id+    m ()+busUnwatchName watcher_id = liftIO $ do+    g_bus_unwatch_name watcher_id+    return ()+++-- function g_bus_unown_name+-- Args : [Arg {argName = "owner_id", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "owner_id", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_bus_unown_name" g_bus_unown_name :: +    Word32 ->                               -- owner_id : TBasicType TUInt32+    IO ()+++busUnownName ::+    (MonadIO m) =>+    Word32 ->                               -- owner_id+    m ()+busUnownName owner_id = liftIO $ do+    g_bus_unown_name owner_id+    return ()+++-- function g_bus_own_name_on_connection_with_closures+-- Args : [Arg {argName = "connection", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "BusNameOwnerFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name_acquired_closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name_lost_closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "connection", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "BusNameOwnerFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name_acquired_closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name_lost_closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_bus_own_name_on_connection_with_closures" g_bus_own_name_on_connection_with_closures :: +    Ptr DBusConnection ->                   -- connection : TInterface "Gio" "DBusConnection"+    CString ->                              -- name : TBasicType TUTF8+    CUInt ->                                -- flags : TInterface "Gio" "BusNameOwnerFlags"+    Ptr Closure ->                          -- name_acquired_closure : TInterface "GObject" "Closure"+    Ptr Closure ->                          -- name_lost_closure : TInterface "GObject" "Closure"+    IO Word32+++busOwnNameOnConnection ::+    (MonadIO m, DBusConnectionK a) =>+    a ->                                    -- connection+    T.Text ->                               -- name+    [BusNameOwnerFlags] ->                  -- flags+    Maybe (Closure) ->                      -- name_acquired_closure+    Maybe (Closure) ->                      -- name_lost_closure+    m Word32+busOwnNameOnConnection connection name flags name_acquired_closure name_lost_closure = liftIO $ do+    let connection' = unsafeManagedPtrCastPtr connection+    name' <- textToCString name+    let flags' = gflagsToWord flags+    maybeName_acquired_closure <- case name_acquired_closure of+        Nothing -> return nullPtr+        Just jName_acquired_closure -> do+            let jName_acquired_closure' = unsafeManagedPtrGetPtr jName_acquired_closure+            return jName_acquired_closure'+    maybeName_lost_closure <- case name_lost_closure of+        Nothing -> return nullPtr+        Just jName_lost_closure -> do+            let jName_lost_closure' = unsafeManagedPtrGetPtr jName_lost_closure+            return jName_lost_closure'+    result <- g_bus_own_name_on_connection_with_closures connection' name' flags' maybeName_acquired_closure maybeName_lost_closure+    touchManagedPtr connection+    whenJust name_acquired_closure touchManagedPtr+    whenJust name_lost_closure touchManagedPtr+    freeMem name'+    return result+++-- function g_bus_own_name_with_closures+-- Args : [Arg {argName = "bus_type", argType = TInterface "Gio" "BusType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "BusNameOwnerFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "bus_acquired_closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name_acquired_closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name_lost_closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "bus_type", argType = TInterface "Gio" "BusType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "BusNameOwnerFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "bus_acquired_closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name_acquired_closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name_lost_closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_bus_own_name_with_closures" g_bus_own_name_with_closures :: +    CUInt ->                                -- bus_type : TInterface "Gio" "BusType"+    CString ->                              -- name : TBasicType TUTF8+    CUInt ->                                -- flags : TInterface "Gio" "BusNameOwnerFlags"+    Ptr Closure ->                          -- bus_acquired_closure : TInterface "GObject" "Closure"+    Ptr Closure ->                          -- name_acquired_closure : TInterface "GObject" "Closure"+    Ptr Closure ->                          -- name_lost_closure : TInterface "GObject" "Closure"+    IO Word32+++busOwnName ::+    (MonadIO m) =>+    BusType ->                              -- bus_type+    T.Text ->                               -- name+    [BusNameOwnerFlags] ->                  -- flags+    Maybe (Closure) ->                      -- bus_acquired_closure+    Maybe (Closure) ->                      -- name_acquired_closure+    Maybe (Closure) ->                      -- name_lost_closure+    m Word32+busOwnName bus_type name flags bus_acquired_closure name_acquired_closure name_lost_closure = liftIO $ do+    let bus_type' = (fromIntegral . fromEnum) bus_type+    name' <- textToCString name+    let flags' = gflagsToWord flags+    maybeBus_acquired_closure <- case bus_acquired_closure of+        Nothing -> return nullPtr+        Just jBus_acquired_closure -> do+            let jBus_acquired_closure' = unsafeManagedPtrGetPtr jBus_acquired_closure+            return jBus_acquired_closure'+    maybeName_acquired_closure <- case name_acquired_closure of+        Nothing -> return nullPtr+        Just jName_acquired_closure -> do+            let jName_acquired_closure' = unsafeManagedPtrGetPtr jName_acquired_closure+            return jName_acquired_closure'+    maybeName_lost_closure <- case name_lost_closure of+        Nothing -> return nullPtr+        Just jName_lost_closure -> do+            let jName_lost_closure' = unsafeManagedPtrGetPtr jName_lost_closure+            return jName_lost_closure'+    result <- g_bus_own_name_with_closures bus_type' name' flags' maybeBus_acquired_closure maybeName_acquired_closure maybeName_lost_closure+    whenJust bus_acquired_closure touchManagedPtr+    whenJust name_acquired_closure touchManagedPtr+    whenJust name_lost_closure touchManagedPtr+    freeMem name'+    return result+++-- function g_bus_get_sync+-- Args : [Arg {argName = "bus_type", argType = TInterface "Gio" "BusType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "bus_type", argType = TInterface "Gio" "BusType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusConnection"+-- throws : True+-- Skip return : False++foreign import ccall "g_bus_get_sync" g_bus_get_sync :: +    CUInt ->                                -- bus_type : TInterface "Gio" "BusType"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr DBusConnection)+++busGetSync ::+    (MonadIO m, CancellableK a) =>+    BusType ->                              -- bus_type+    Maybe (a) ->                            -- cancellable+    m DBusConnection+busGetSync bus_type cancellable = liftIO $ do+    let bus_type' = (fromIntegral . fromEnum) bus_type+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_bus_get_sync bus_type' maybeCancellable+        checkUnexpectedReturnNULL "g_bus_get_sync" result+        result' <- (wrapObject DBusConnection) result+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )+++-- function g_bus_get_finish+-- Args : [Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusConnection"+-- throws : True+-- Skip return : False++foreign import ccall "g_bus_get_finish" g_bus_get_finish :: +    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr DBusConnection)+++busGetFinish ::+    (MonadIO m, AsyncResultK a) =>+    a ->                                    -- res+    m DBusConnection+busGetFinish res = liftIO $ do+    let res' = unsafeManagedPtrCastPtr res+    onException (do+        result <- propagateGError $ g_bus_get_finish res'+        checkUnexpectedReturnNULL "g_bus_get_finish" result+        result' <- (wrapObject DBusConnection) result+        touchManagedPtr res+        return result'+     ) (do+        return ()+     )+++-- function g_bus_get+-- Args : [Arg {argName = "bus_type", argType = TInterface "Gio" "BusType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "bus_type", argType = TInterface "Gio" "BusType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_bus_get" g_bus_get :: +    CUInt ->                                -- bus_type : TInterface "Gio" "BusType"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++busGet ::+    (MonadIO m, CancellableK a) =>+    BusType ->                              -- bus_type+    Maybe (a) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+busGet bus_type cancellable callback = liftIO $ do+    let bus_type' = (fromIntegral . fromEnum) bus_type+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_bus_get bus_type' maybeCancellable maybeCallback user_data+    whenJust cancellable touchManagedPtr+    return ()+++-- function g_async_initable_newv_async+-- Args : [Arg {argName = "object_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_parameters", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameters", argType = TInterface "GObject" "Parameter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "object_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_parameters", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameters", argType = TInterface "GObject" "Parameter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_async_initable_newv_async" g_async_initable_newv_async :: +    CGType ->                               -- object_type : TBasicType TGType+    Word32 ->                               -- n_parameters : TBasicType TUInt32+    Ptr GObject.Parameter ->                -- parameters : TInterface "GObject" "Parameter"+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++asyncInitableNewvAsync ::+    (MonadIO m, CancellableK a) =>+    GType ->                                -- object_type+    Word32 ->                               -- n_parameters+    GObject.Parameter ->                    -- parameters+    Int32 ->                                -- io_priority+    Maybe (a) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+asyncInitableNewvAsync object_type n_parameters parameters io_priority cancellable callback = liftIO $ do+    let object_type' = gtypeToCGType object_type+    let parameters' = unsafeManagedPtrGetPtr parameters+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_async_initable_newv_async object_type' n_parameters parameters' io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr parameters+    whenJust cancellable touchManagedPtr+    return ()+++-- function g_app_info_reset_type_associations+-- Args : [Arg {argName = "content_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "content_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_app_info_reset_type_associations" g_app_info_reset_type_associations :: +    CString ->                              -- content_type : TBasicType TUTF8+    IO ()+++appInfoResetTypeAssociations ::+    (MonadIO m) =>+    T.Text ->                               -- content_type+    m ()+appInfoResetTypeAssociations content_type = liftIO $ do+    content_type' <- textToCString content_type+    g_app_info_reset_type_associations content_type'+    freeMem content_type'+    return ()+++-- function g_app_info_launch_default_for_uri+-- Args : [Arg {argName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "launch_context", argType = TInterface "Gio" "AppLaunchContext", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "launch_context", argType = TInterface "Gio" "AppLaunchContext", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_app_info_launch_default_for_uri" g_app_info_launch_default_for_uri :: +    CString ->                              -- uri : TBasicType TUTF8+    Ptr AppLaunchContext ->                 -- launch_context : TInterface "Gio" "AppLaunchContext"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++appInfoLaunchDefaultForUri ::+    (MonadIO m, AppLaunchContextK a) =>+    T.Text ->                               -- uri+    Maybe (a) ->                            -- launch_context+    m ()+appInfoLaunchDefaultForUri uri launch_context = liftIO $ do+    uri' <- textToCString uri+    maybeLaunch_context <- case launch_context of+        Nothing -> return nullPtr+        Just jLaunch_context -> do+            let jLaunch_context' = unsafeManagedPtrCastPtr jLaunch_context+            return jLaunch_context'+    onException (do+        _ <- propagateGError $ g_app_info_launch_default_for_uri uri' maybeLaunch_context+        whenJust launch_context touchManagedPtr+        freeMem uri'+        return ()+     ) (do+        freeMem uri'+     )+++-- function g_app_info_get_recommended_for_type+-- Args : [Arg {argName = "content_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "content_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gio" "AppInfo")+-- throws : False+-- Skip return : False++foreign import ccall "g_app_info_get_recommended_for_type" g_app_info_get_recommended_for_type :: +    CString ->                              -- content_type : TBasicType TUTF8+    IO (Ptr (GList (Ptr AppInfo)))+++appInfoGetRecommendedForType ::+    (MonadIO m) =>+    T.Text ->                               -- content_type+    m [AppInfo]+appInfoGetRecommendedForType content_type = liftIO $ do+    content_type' <- textToCString content_type+    result <- g_app_info_get_recommended_for_type content_type'+    checkUnexpectedReturnNULL "g_app_info_get_recommended_for_type" result+    result' <- unpackGList result+    result'' <- mapM (wrapObject AppInfo) result'+    g_list_free result+    freeMem content_type'+    return result''+++-- function g_app_info_get_fallback_for_type+-- Args : [Arg {argName = "content_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "content_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gio" "AppInfo")+-- throws : False+-- Skip return : False++foreign import ccall "g_app_info_get_fallback_for_type" g_app_info_get_fallback_for_type :: +    CString ->                              -- content_type : TBasicType TUTF8+    IO (Ptr (GList (Ptr AppInfo)))+++appInfoGetFallbackForType ::+    (MonadIO m) =>+    T.Text ->                               -- content_type+    m [AppInfo]+appInfoGetFallbackForType content_type = liftIO $ do+    content_type' <- textToCString content_type+    result <- g_app_info_get_fallback_for_type content_type'+    checkUnexpectedReturnNULL "g_app_info_get_fallback_for_type" result+    result' <- unpackGList result+    result'' <- mapM (wrapObject AppInfo) result'+    g_list_free result+    freeMem content_type'+    return result''+++-- function g_app_info_get_default_for_uri_scheme+-- Args : [Arg {argName = "uri_scheme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "uri_scheme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "AppInfo"+-- throws : False+-- Skip return : False++foreign import ccall "g_app_info_get_default_for_uri_scheme" g_app_info_get_default_for_uri_scheme :: +    CString ->                              -- uri_scheme : TBasicType TUTF8+    IO (Ptr AppInfo)+++appInfoGetDefaultForUriScheme ::+    (MonadIO m) =>+    T.Text ->                               -- uri_scheme+    m AppInfo+appInfoGetDefaultForUriScheme uri_scheme = liftIO $ do+    uri_scheme' <- textToCString uri_scheme+    result <- g_app_info_get_default_for_uri_scheme uri_scheme'+    checkUnexpectedReturnNULL "g_app_info_get_default_for_uri_scheme" result+    result' <- (wrapObject AppInfo) result+    freeMem uri_scheme'+    return result'+++-- function g_app_info_get_default_for_type+-- Args : [Arg {argName = "content_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "must_support_uris", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "content_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "must_support_uris", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "AppInfo"+-- throws : False+-- Skip return : False++foreign import ccall "g_app_info_get_default_for_type" g_app_info_get_default_for_type :: +    CString ->                              -- content_type : TBasicType TUTF8+    CInt ->                                 -- must_support_uris : TBasicType TBoolean+    IO (Ptr AppInfo)+++appInfoGetDefaultForType ::+    (MonadIO m) =>+    T.Text ->                               -- content_type+    Bool ->                                 -- must_support_uris+    m AppInfo+appInfoGetDefaultForType content_type must_support_uris = liftIO $ do+    content_type' <- textToCString content_type+    let must_support_uris' = (fromIntegral . fromEnum) must_support_uris+    result <- g_app_info_get_default_for_type content_type' must_support_uris'+    checkUnexpectedReturnNULL "g_app_info_get_default_for_type" result+    result' <- (wrapObject AppInfo) result+    freeMem content_type'+    return result'+++-- function g_app_info_get_all_for_type+-- Args : [Arg {argName = "content_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "content_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gio" "AppInfo")+-- throws : False+-- Skip return : False++foreign import ccall "g_app_info_get_all_for_type" g_app_info_get_all_for_type :: +    CString ->                              -- content_type : TBasicType TUTF8+    IO (Ptr (GList (Ptr AppInfo)))+++appInfoGetAllForType ::+    (MonadIO m) =>+    T.Text ->                               -- content_type+    m [AppInfo]+appInfoGetAllForType content_type = liftIO $ do+    content_type' <- textToCString content_type+    result <- g_app_info_get_all_for_type content_type'+    checkUnexpectedReturnNULL "g_app_info_get_all_for_type" result+    result' <- unpackGList result+    result'' <- mapM (wrapObject AppInfo) result'+    g_list_free result+    freeMem content_type'+    return result''+++-- function g_app_info_get_all+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TGList (TInterface "Gio" "AppInfo")+-- throws : False+-- Skip return : False++foreign import ccall "g_app_info_get_all" g_app_info_get_all :: +    IO (Ptr (GList (Ptr AppInfo)))+++appInfoGetAll ::+    (MonadIO m) =>+    m [AppInfo]+appInfoGetAll  = liftIO $ do+    result <- g_app_info_get_all+    checkUnexpectedReturnNULL "g_app_info_get_all" result+    result' <- unpackGList result+    result'' <- mapM (wrapObject AppInfo) result'+    g_list_free result+    return result''+++-- function g_app_info_create_from_commandline+-- Args : [Arg {argName = "commandline", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "application_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "AppInfoCreateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "commandline", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "application_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "AppInfoCreateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "AppInfo"+-- throws : True+-- Skip return : False++foreign import ccall "g_app_info_create_from_commandline" g_app_info_create_from_commandline :: +    CString ->                              -- commandline : TBasicType TUTF8+    CString ->                              -- application_name : TBasicType TUTF8+    CUInt ->                                -- flags : TInterface "Gio" "AppInfoCreateFlags"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr AppInfo)+++appInfoCreateFromCommandline ::+    (MonadIO m) =>+    T.Text ->                               -- commandline+    Maybe (T.Text) ->                       -- application_name+    [AppInfoCreateFlags] ->                 -- flags+    m AppInfo+appInfoCreateFromCommandline commandline application_name flags = liftIO $ do+    commandline' <- textToCString commandline+    maybeApplication_name <- case application_name of+        Nothing -> return nullPtr+        Just jApplication_name -> do+            jApplication_name' <- textToCString jApplication_name+            return jApplication_name'+    let flags' = gflagsToWord flags+    onException (do+        result <- propagateGError $ g_app_info_create_from_commandline commandline' maybeApplication_name flags'+        checkUnexpectedReturnNULL "g_app_info_create_from_commandline" result+        result' <- (wrapObject AppInfo) result+        freeMem commandline'+        freeMem maybeApplication_name+        return result'+     ) (do+        freeMem commandline'+        freeMem maybeApplication_name+     )+++-- function g_action_print_detailed_name+-- Args : [Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "target_value", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "target_value", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_action_print_detailed_name" g_action_print_detailed_name :: +    CString ->                              -- action_name : TBasicType TUTF8+    Ptr GVariant ->                         -- target_value : TVariant+    IO CString+++actionPrintDetailedName ::+    (MonadIO m) =>+    T.Text ->                               -- action_name+    Maybe (GVariant) ->                     -- target_value+    m T.Text+actionPrintDetailedName action_name target_value = liftIO $ do+    action_name' <- textToCString action_name+    maybeTarget_value <- case target_value of+        Nothing -> return nullPtr+        Just jTarget_value -> do+            let jTarget_value' = unsafeManagedPtrGetPtr jTarget_value+            return jTarget_value'+    result <- g_action_print_detailed_name action_name' maybeTarget_value+    checkUnexpectedReturnNULL "g_action_print_detailed_name" result+    result' <- cstringToText result+    freeMem result+    freeMem action_name'+    return result'+++-- function g_action_parse_detailed_name+-- Args : [Arg {argName = "detailed_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "target_value", argType = TVariant, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "detailed_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_action_parse_detailed_name" g_action_parse_detailed_name :: +    CString ->                              -- detailed_name : TBasicType TUTF8+    Ptr CString ->                          -- action_name : TBasicType TUTF8+    Ptr (Ptr GVariant) ->                   -- target_value : TVariant+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++actionParseDetailedName ::+    (MonadIO m) =>+    T.Text ->                               -- detailed_name+    m (T.Text,GVariant)+actionParseDetailedName detailed_name = liftIO $ do+    detailed_name' <- textToCString detailed_name+    action_name <- allocMem :: IO (Ptr CString)+    target_value <- allocMem :: IO (Ptr (Ptr GVariant))+    onException (do+        _ <- propagateGError $ g_action_parse_detailed_name detailed_name' action_name target_value+        action_name' <- peek action_name+        action_name'' <- cstringToText action_name'+        freeMem action_name'+        target_value' <- peek target_value+        target_value'' <- wrapGVariantPtr target_value'+        freeMem detailed_name'+        freeMem action_name+        freeMem target_value+        return (action_name'', target_value'')+     ) (do+        freeMem detailed_name'+        freeMem action_name+        freeMem target_value+     )+++-- function g_action_name_is_valid+-- Args : [Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_action_name_is_valid" g_action_name_is_valid :: +    CString ->                              -- action_name : TBasicType TUTF8+    IO CInt+++actionNameIsValid ::+    (MonadIO m) =>+    T.Text ->                               -- action_name+    m Bool+actionNameIsValid action_name = liftIO $ do+    action_name' <- textToCString action_name+    result <- g_action_name_is_valid action_name'+    let result' = (/= 0) result+    freeMem action_name'+    return result'+++
+ GI/Gio/Interfaces.hs view
@@ -0,0 +1,88 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Interfaces+    (     module GI.Gio.Interfaces.Action         ,+    module GI.Gio.Interfaces.ActionGroup    ,+    module GI.Gio.Interfaces.ActionMap      ,+    module GI.Gio.Interfaces.AppInfo        ,+    module GI.Gio.Interfaces.AsyncInitable  ,+    module GI.Gio.Interfaces.AsyncResult    ,+    module GI.Gio.Interfaces.Converter      ,+    module GI.Gio.Interfaces.DBusInterface  ,+    module GI.Gio.Interfaces.DBusObject     ,+    module GI.Gio.Interfaces.DBusObjectManager,+    module GI.Gio.Interfaces.DesktopAppInfoLookup,+    module GI.Gio.Interfaces.Drive          ,+    module GI.Gio.Interfaces.File           ,+    module GI.Gio.Interfaces.FileDescriptorBased,+    module GI.Gio.Interfaces.Icon           ,+    module GI.Gio.Interfaces.Initable       ,+    module GI.Gio.Interfaces.ListModel      ,+    module GI.Gio.Interfaces.LoadableIcon   ,+    module GI.Gio.Interfaces.Mount          ,+    module GI.Gio.Interfaces.NetworkMonitor ,+    module GI.Gio.Interfaces.PollableInputStream,+    module GI.Gio.Interfaces.PollableOutputStream,+    module GI.Gio.Interfaces.Proxy          ,+    module GI.Gio.Interfaces.ProxyResolver  ,+    module GI.Gio.Interfaces.RemoteActionGroup,+    module GI.Gio.Interfaces.Seekable       ,+    module GI.Gio.Interfaces.SocketConnectable,+    module GI.Gio.Interfaces.TlsBackend     ,+    module GI.Gio.Interfaces.TlsClientConnection,+    module GI.Gio.Interfaces.TlsFileDatabase,+    module GI.Gio.Interfaces.TlsServerConnection,+    module GI.Gio.Interfaces.Volume         ,+++    ) where++import GI.Gio.Interfaces.Action+import GI.Gio.Interfaces.ActionGroup+import GI.Gio.Interfaces.ActionMap+import GI.Gio.Interfaces.AppInfo+import GI.Gio.Interfaces.AsyncInitable+import GI.Gio.Interfaces.AsyncResult+import GI.Gio.Interfaces.Converter+import GI.Gio.Interfaces.DBusInterface+import GI.Gio.Interfaces.DBusObject+import GI.Gio.Interfaces.DBusObjectManager+import GI.Gio.Interfaces.DesktopAppInfoLookup+import GI.Gio.Interfaces.Drive+import GI.Gio.Interfaces.File+import GI.Gio.Interfaces.FileDescriptorBased+import GI.Gio.Interfaces.Icon+import GI.Gio.Interfaces.Initable+import GI.Gio.Interfaces.ListModel+import GI.Gio.Interfaces.LoadableIcon+import GI.Gio.Interfaces.Mount+import GI.Gio.Interfaces.NetworkMonitor+import GI.Gio.Interfaces.PollableInputStream+import GI.Gio.Interfaces.PollableOutputStream+import GI.Gio.Interfaces.Proxy+import GI.Gio.Interfaces.ProxyResolver+import GI.Gio.Interfaces.RemoteActionGroup+import GI.Gio.Interfaces.Seekable+import GI.Gio.Interfaces.SocketConnectable+import GI.Gio.Interfaces.TlsBackend+import GI.Gio.Interfaces.TlsClientConnection+import GI.Gio.Interfaces.TlsFileDatabase+import GI.Gio.Interfaces.TlsServerConnection+import GI.Gio.Interfaces.Volume++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks++
+ GI/Gio/Interfaces/Action.hs view
@@ -0,0 +1,427 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Interfaces.Action+    ( ++-- * Exported types+    Action(..)                              ,+    noAction                                ,+    ActionK                                 ,+    toAction                                ,+++ -- * Methods+-- ** actionActivate+    actionActivate                          ,+++-- ** actionChangeState+    actionChangeState                       ,+++-- ** actionGetEnabled+    actionGetEnabled                        ,+++-- ** actionGetName+    actionGetName                           ,+++-- ** actionGetParameterType+    actionGetParameterType                  ,+++-- ** actionGetState+    actionGetState                          ,+++-- ** actionGetStateHint+    actionGetStateHint                      ,+++-- ** actionGetStateType+    actionGetStateType                      ,+++++ -- * Properties+-- ** Enabled+    ActionEnabledPropertyInfo               ,+    getActionEnabled                        ,+++-- ** Name+    ActionNamePropertyInfo                  ,+    getActionName                           ,+++-- ** ParameterType+    ActionParameterTypePropertyInfo         ,+    getActionParameterType                  ,+++-- ** State+    ActionStatePropertyInfo                 ,+    getActionState                          ,+++-- ** StateType+    ActionStateTypePropertyInfo             ,+    getActionStateType                      ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++-- interface Action ++newtype Action = Action (ForeignPtr Action)+noAction :: Maybe Action+noAction = Nothing++-- VVV Prop "enabled"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getActionEnabled :: (MonadIO m, ActionK o) => o -> m Bool+getActionEnabled obj = liftIO $ getObjectPropertyBool obj "enabled"++data ActionEnabledPropertyInfo+instance AttrInfo ActionEnabledPropertyInfo where+    type AttrAllowedOps ActionEnabledPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint ActionEnabledPropertyInfo = (~) ()+    type AttrBaseTypeConstraint ActionEnabledPropertyInfo = ActionK+    type AttrGetType ActionEnabledPropertyInfo = Bool+    type AttrLabel ActionEnabledPropertyInfo = "Action::enabled"+    attrGet _ = getActionEnabled+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "name"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable]++getActionName :: (MonadIO m, ActionK o) => o -> m T.Text+getActionName obj = liftIO $ getObjectPropertyString obj "name"++data ActionNamePropertyInfo+instance AttrInfo ActionNamePropertyInfo where+    type AttrAllowedOps ActionNamePropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint ActionNamePropertyInfo = (~) ()+    type AttrBaseTypeConstraint ActionNamePropertyInfo = ActionK+    type AttrGetType ActionNamePropertyInfo = T.Text+    type AttrLabel ActionNamePropertyInfo = "Action::name"+    attrGet _ = getActionName+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "parameter-type"+   -- Type: TInterface "GLib" "VariantType"+   -- Flags: [PropertyReadable]++getActionParameterType :: (MonadIO m, ActionK o) => o -> m GLib.VariantType+getActionParameterType obj = liftIO $ getObjectPropertyBoxed obj "parameter-type" GLib.VariantType++data ActionParameterTypePropertyInfo+instance AttrInfo ActionParameterTypePropertyInfo where+    type AttrAllowedOps ActionParameterTypePropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint ActionParameterTypePropertyInfo = (~) ()+    type AttrBaseTypeConstraint ActionParameterTypePropertyInfo = ActionK+    type AttrGetType ActionParameterTypePropertyInfo = GLib.VariantType+    type AttrLabel ActionParameterTypePropertyInfo = "Action::parameter-type"+    attrGet _ = getActionParameterType+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "state"+   -- Type: TVariant+   -- Flags: [PropertyReadable]++getActionState :: (MonadIO m, ActionK o) => o -> m GVariant+getActionState obj = liftIO $ getObjectPropertyVariant obj "state"++data ActionStatePropertyInfo+instance AttrInfo ActionStatePropertyInfo where+    type AttrAllowedOps ActionStatePropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint ActionStatePropertyInfo = (~) ()+    type AttrBaseTypeConstraint ActionStatePropertyInfo = ActionK+    type AttrGetType ActionStatePropertyInfo = GVariant+    type AttrLabel ActionStatePropertyInfo = "Action::state"+    attrGet _ = getActionState+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "state-type"+   -- Type: TInterface "GLib" "VariantType"+   -- Flags: [PropertyReadable]++getActionStateType :: (MonadIO m, ActionK o) => o -> m GLib.VariantType+getActionStateType obj = liftIO $ getObjectPropertyBoxed obj "state-type" GLib.VariantType++data ActionStateTypePropertyInfo+instance AttrInfo ActionStateTypePropertyInfo where+    type AttrAllowedOps ActionStateTypePropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint ActionStateTypePropertyInfo = (~) ()+    type AttrBaseTypeConstraint ActionStateTypePropertyInfo = ActionK+    type AttrGetType ActionStateTypePropertyInfo = GLib.VariantType+    type AttrLabel ActionStateTypePropertyInfo = "Action::state-type"+    attrGet _ = getActionStateType+    attrSet _ = undefined+    attrConstruct _ = undefined++type instance AttributeList Action = ActionAttributeList+type ActionAttributeList = ('[ '("enabled", ActionEnabledPropertyInfo), '("name", ActionNamePropertyInfo), '("parameter-type", ActionParameterTypePropertyInfo), '("state", ActionStatePropertyInfo), '("state-type", ActionStateTypePropertyInfo)] :: [(Symbol, *)])++type instance SignalList Action = ActionSignalList+type ActionSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "g_action_get_type"+    c_g_action_get_type :: IO GType++type instance ParentTypes Action = ActionParentTypes+type ActionParentTypes = '[GObject.Object]++instance GObject Action where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_action_get_type+    ++class GObject o => ActionK o+instance (GObject o, IsDescendantOf Action o) => ActionK o++toAction :: ActionK o => o -> IO Action+toAction = unsafeCastTo Action++-- method Action::activate+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameter", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameter", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_action_activate" g_action_activate :: +    Ptr Action ->                           -- _obj : TInterface "Gio" "Action"+    Ptr GVariant ->                         -- parameter : TVariant+    IO ()+++actionActivate ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    Maybe (GVariant) ->                     -- parameter+    m ()+actionActivate _obj parameter = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeParameter <- case parameter of+        Nothing -> return nullPtr+        Just jParameter -> do+            let jParameter' = unsafeManagedPtrGetPtr jParameter+            return jParameter'+    g_action_activate _obj' maybeParameter+    touchManagedPtr _obj+    return ()++-- method Action::change_state+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TVariant, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TVariant, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_action_change_state" g_action_change_state :: +    Ptr Action ->                           -- _obj : TInterface "Gio" "Action"+    Ptr GVariant ->                         -- value : TVariant+    IO ()+++actionChangeState ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    GVariant ->                             -- value+    m ()+actionChangeState _obj value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let value' = unsafeManagedPtrGetPtr value+    g_action_change_state _obj' value'+    touchManagedPtr _obj+    return ()++-- method Action::get_enabled+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_action_get_enabled" g_action_get_enabled :: +    Ptr Action ->                           -- _obj : TInterface "Gio" "Action"+    IO CInt+++actionGetEnabled ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    m Bool+actionGetEnabled _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_action_get_enabled _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Action::get_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_action_get_name" g_action_get_name :: +    Ptr Action ->                           -- _obj : TInterface "Gio" "Action"+    IO CString+++actionGetName ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    m T.Text+actionGetName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_action_get_name _obj'+    checkUnexpectedReturnNULL "g_action_get_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Action::get_parameter_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GLib" "VariantType"+-- throws : False+-- Skip return : False++foreign import ccall "g_action_get_parameter_type" g_action_get_parameter_type :: +    Ptr Action ->                           -- _obj : TInterface "Gio" "Action"+    IO (Ptr GLib.VariantType)+++actionGetParameterType ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    m GLib.VariantType+actionGetParameterType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_action_get_parameter_type _obj'+    checkUnexpectedReturnNULL "g_action_get_parameter_type" result+    result' <- (newBoxed GLib.VariantType) result+    touchManagedPtr _obj+    return result'++-- method Action::get_state+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TVariant+-- throws : False+-- Skip return : False++foreign import ccall "g_action_get_state" g_action_get_state :: +    Ptr Action ->                           -- _obj : TInterface "Gio" "Action"+    IO (Ptr GVariant)+++actionGetState ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    m GVariant+actionGetState _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_action_get_state _obj'+    checkUnexpectedReturnNULL "g_action_get_state" result+    result' <- wrapGVariantPtr result+    touchManagedPtr _obj+    return result'++-- method Action::get_state_hint+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TVariant+-- throws : False+-- Skip return : False++foreign import ccall "g_action_get_state_hint" g_action_get_state_hint :: +    Ptr Action ->                           -- _obj : TInterface "Gio" "Action"+    IO (Ptr GVariant)+++actionGetStateHint ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    m GVariant+actionGetStateHint _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_action_get_state_hint _obj'+    checkUnexpectedReturnNULL "g_action_get_state_hint" result+    result' <- wrapGVariantPtr result+    touchManagedPtr _obj+    return result'++-- method Action::get_state_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GLib" "VariantType"+-- throws : False+-- Skip return : False++foreign import ccall "g_action_get_state_type" g_action_get_state_type :: +    Ptr Action ->                           -- _obj : TInterface "Gio" "Action"+    IO (Ptr GLib.VariantType)+++actionGetStateType ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    m GLib.VariantType+actionGetStateType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_action_get_state_type _obj'+    checkUnexpectedReturnNULL "g_action_get_state_type" result+    result' <- (newBoxed GLib.VariantType) result+    touchManagedPtr _obj+    return result'++
+ GI/Gio/Interfaces/Action.hs-boot view
@@ -0,0 +1,18 @@+module GI.Gio.Interfaces.Action where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Action = Action (ForeignPtr Action)+data ActionEnabledPropertyInfo+data ActionNamePropertyInfo+data ActionParameterTypePropertyInfo+data ActionStatePropertyInfo+data ActionStateTypePropertyInfo+instance GObject Action where+class GObject o => ActionK o+instance (GObject o, IsDescendantOf Action o) => ActionK o
+ GI/Gio/Interfaces/ActionGroup.hs view
@@ -0,0 +1,811 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Interfaces.ActionGroup+    ( ++-- * Exported types+    ActionGroup(..)                         ,+    noActionGroup                           ,+    ActionGroupK                            ,+    toActionGroup                           ,+++ -- * Methods+-- ** actionGroupActionAdded+    actionGroupActionAdded                  ,+++-- ** actionGroupActionEnabledChanged+    actionGroupActionEnabledChanged         ,+++-- ** actionGroupActionRemoved+    actionGroupActionRemoved                ,+++-- ** actionGroupActionStateChanged+    actionGroupActionStateChanged           ,+++-- ** actionGroupActivateAction+    actionGroupActivateAction               ,+++-- ** actionGroupChangeActionState+    actionGroupChangeActionState            ,+++-- ** actionGroupGetActionEnabled+    actionGroupGetActionEnabled             ,+++-- ** actionGroupGetActionParameterType+    actionGroupGetActionParameterType       ,+++-- ** actionGroupGetActionState+    actionGroupGetActionState               ,+++-- ** actionGroupGetActionStateHint+    actionGroupGetActionStateHint           ,+++-- ** actionGroupGetActionStateType+    actionGroupGetActionStateType           ,+++-- ** actionGroupHasAction+    actionGroupHasAction                    ,+++-- ** actionGroupListActions+    actionGroupListActions                  ,+++-- ** actionGroupQueryAction+    actionGroupQueryAction                  ,+++++ -- * Signals+-- ** ActionAdded+    ActionGroupActionAddedCallback          ,+    ActionGroupActionAddedCallbackC         ,+    ActionGroupActionAddedSignalInfo        ,+    actionGroupActionAddedCallbackWrapper   ,+    actionGroupActionAddedClosure           ,+    afterActionGroupActionAdded             ,+    mkActionGroupActionAddedCallback        ,+    noActionGroupActionAddedCallback        ,+    onActionGroupActionAdded                ,+++-- ** ActionEnabledChanged+    ActionGroupActionEnabledChangedCallback ,+    ActionGroupActionEnabledChangedCallbackC,+    ActionGroupActionEnabledChangedSignalInfo,+    actionGroupActionEnabledChangedCallbackWrapper,+    actionGroupActionEnabledChangedClosure  ,+    afterActionGroupActionEnabledChanged    ,+    mkActionGroupActionEnabledChangedCallback,+    noActionGroupActionEnabledChangedCallback,+    onActionGroupActionEnabledChanged       ,+++-- ** ActionRemoved+    ActionGroupActionRemovedCallback        ,+    ActionGroupActionRemovedCallbackC       ,+    ActionGroupActionRemovedSignalInfo      ,+    actionGroupActionRemovedCallbackWrapper ,+    actionGroupActionRemovedClosure         ,+    afterActionGroupActionRemoved           ,+    mkActionGroupActionRemovedCallback      ,+    noActionGroupActionRemovedCallback      ,+    onActionGroupActionRemoved              ,+++-- ** ActionStateChanged+    ActionGroupActionStateChangedCallback   ,+    ActionGroupActionStateChangedCallbackC  ,+    ActionGroupActionStateChangedSignalInfo ,+    actionGroupActionStateChangedCallbackWrapper,+    actionGroupActionStateChangedClosure    ,+    afterActionGroupActionStateChanged      ,+    mkActionGroupActionStateChangedCallback ,+    noActionGroupActionStateChangedCallback ,+    onActionGroupActionStateChanged         ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++-- interface ActionGroup ++newtype ActionGroup = ActionGroup (ForeignPtr ActionGroup)+noActionGroup :: Maybe ActionGroup+noActionGroup = Nothing++-- signal ActionGroup::action-added+type ActionGroupActionAddedCallback =+    T.Text ->+    IO ()++noActionGroupActionAddedCallback :: Maybe ActionGroupActionAddedCallback+noActionGroupActionAddedCallback = Nothing++type ActionGroupActionAddedCallbackC =+    Ptr () ->                               -- object+    CString ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkActionGroupActionAddedCallback :: ActionGroupActionAddedCallbackC -> IO (FunPtr ActionGroupActionAddedCallbackC)++actionGroupActionAddedClosure :: ActionGroupActionAddedCallback -> IO Closure+actionGroupActionAddedClosure cb = newCClosure =<< mkActionGroupActionAddedCallback wrapped+    where wrapped = actionGroupActionAddedCallbackWrapper cb++actionGroupActionAddedCallbackWrapper ::+    ActionGroupActionAddedCallback ->+    Ptr () ->+    CString ->+    Ptr () ->+    IO ()+actionGroupActionAddedCallbackWrapper _cb _ action_name _ = do+    action_name' <- cstringToText action_name+    _cb  action_name'++onActionGroupActionAdded :: (GObject a, MonadIO m) => a -> ActionGroupActionAddedCallback -> m SignalHandlerId+onActionGroupActionAdded obj cb = liftIO $ connectActionGroupActionAdded obj cb SignalConnectBefore+afterActionGroupActionAdded :: (GObject a, MonadIO m) => a -> ActionGroupActionAddedCallback -> m SignalHandlerId+afterActionGroupActionAdded obj cb = connectActionGroupActionAdded obj cb SignalConnectAfter++connectActionGroupActionAdded :: (GObject a, MonadIO m) =>+                                 a -> ActionGroupActionAddedCallback -> SignalConnectMode -> m SignalHandlerId+connectActionGroupActionAdded obj cb after = liftIO $ do+    cb' <- mkActionGroupActionAddedCallback (actionGroupActionAddedCallbackWrapper cb)+    connectSignalFunPtr obj "action-added" cb' after++-- signal ActionGroup::action-enabled-changed+type ActionGroupActionEnabledChangedCallback =+    T.Text ->+    Bool ->+    IO ()++noActionGroupActionEnabledChangedCallback :: Maybe ActionGroupActionEnabledChangedCallback+noActionGroupActionEnabledChangedCallback = Nothing++type ActionGroupActionEnabledChangedCallbackC =+    Ptr () ->                               -- object+    CString ->+    CInt ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkActionGroupActionEnabledChangedCallback :: ActionGroupActionEnabledChangedCallbackC -> IO (FunPtr ActionGroupActionEnabledChangedCallbackC)++actionGroupActionEnabledChangedClosure :: ActionGroupActionEnabledChangedCallback -> IO Closure+actionGroupActionEnabledChangedClosure cb = newCClosure =<< mkActionGroupActionEnabledChangedCallback wrapped+    where wrapped = actionGroupActionEnabledChangedCallbackWrapper cb++actionGroupActionEnabledChangedCallbackWrapper ::+    ActionGroupActionEnabledChangedCallback ->+    Ptr () ->+    CString ->+    CInt ->+    Ptr () ->+    IO ()+actionGroupActionEnabledChangedCallbackWrapper _cb _ action_name enabled _ = do+    action_name' <- cstringToText action_name+    let enabled' = (/= 0) enabled+    _cb  action_name' enabled'++onActionGroupActionEnabledChanged :: (GObject a, MonadIO m) => a -> ActionGroupActionEnabledChangedCallback -> m SignalHandlerId+onActionGroupActionEnabledChanged obj cb = liftIO $ connectActionGroupActionEnabledChanged obj cb SignalConnectBefore+afterActionGroupActionEnabledChanged :: (GObject a, MonadIO m) => a -> ActionGroupActionEnabledChangedCallback -> m SignalHandlerId+afterActionGroupActionEnabledChanged obj cb = connectActionGroupActionEnabledChanged obj cb SignalConnectAfter++connectActionGroupActionEnabledChanged :: (GObject a, MonadIO m) =>+                                          a -> ActionGroupActionEnabledChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectActionGroupActionEnabledChanged obj cb after = liftIO $ do+    cb' <- mkActionGroupActionEnabledChangedCallback (actionGroupActionEnabledChangedCallbackWrapper cb)+    connectSignalFunPtr obj "action-enabled-changed" cb' after++-- signal ActionGroup::action-removed+type ActionGroupActionRemovedCallback =+    T.Text ->+    IO ()++noActionGroupActionRemovedCallback :: Maybe ActionGroupActionRemovedCallback+noActionGroupActionRemovedCallback = Nothing++type ActionGroupActionRemovedCallbackC =+    Ptr () ->                               -- object+    CString ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkActionGroupActionRemovedCallback :: ActionGroupActionRemovedCallbackC -> IO (FunPtr ActionGroupActionRemovedCallbackC)++actionGroupActionRemovedClosure :: ActionGroupActionRemovedCallback -> IO Closure+actionGroupActionRemovedClosure cb = newCClosure =<< mkActionGroupActionRemovedCallback wrapped+    where wrapped = actionGroupActionRemovedCallbackWrapper cb++actionGroupActionRemovedCallbackWrapper ::+    ActionGroupActionRemovedCallback ->+    Ptr () ->+    CString ->+    Ptr () ->+    IO ()+actionGroupActionRemovedCallbackWrapper _cb _ action_name _ = do+    action_name' <- cstringToText action_name+    _cb  action_name'++onActionGroupActionRemoved :: (GObject a, MonadIO m) => a -> ActionGroupActionRemovedCallback -> m SignalHandlerId+onActionGroupActionRemoved obj cb = liftIO $ connectActionGroupActionRemoved obj cb SignalConnectBefore+afterActionGroupActionRemoved :: (GObject a, MonadIO m) => a -> ActionGroupActionRemovedCallback -> m SignalHandlerId+afterActionGroupActionRemoved obj cb = connectActionGroupActionRemoved obj cb SignalConnectAfter++connectActionGroupActionRemoved :: (GObject a, MonadIO m) =>+                                   a -> ActionGroupActionRemovedCallback -> SignalConnectMode -> m SignalHandlerId+connectActionGroupActionRemoved obj cb after = liftIO $ do+    cb' <- mkActionGroupActionRemovedCallback (actionGroupActionRemovedCallbackWrapper cb)+    connectSignalFunPtr obj "action-removed" cb' after++-- signal ActionGroup::action-state-changed+type ActionGroupActionStateChangedCallback =+    T.Text ->+    GVariant ->+    IO ()++noActionGroupActionStateChangedCallback :: Maybe ActionGroupActionStateChangedCallback+noActionGroupActionStateChangedCallback = Nothing++type ActionGroupActionStateChangedCallbackC =+    Ptr () ->                               -- object+    CString ->+    Ptr GVariant ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkActionGroupActionStateChangedCallback :: ActionGroupActionStateChangedCallbackC -> IO (FunPtr ActionGroupActionStateChangedCallbackC)++actionGroupActionStateChangedClosure :: ActionGroupActionStateChangedCallback -> IO Closure+actionGroupActionStateChangedClosure cb = newCClosure =<< mkActionGroupActionStateChangedCallback wrapped+    where wrapped = actionGroupActionStateChangedCallbackWrapper cb++actionGroupActionStateChangedCallbackWrapper ::+    ActionGroupActionStateChangedCallback ->+    Ptr () ->+    CString ->+    Ptr GVariant ->+    Ptr () ->+    IO ()+actionGroupActionStateChangedCallbackWrapper _cb _ action_name value _ = do+    action_name' <- cstringToText action_name+    value' <- newGVariantFromPtr value+    _cb  action_name' value'++onActionGroupActionStateChanged :: (GObject a, MonadIO m) => a -> ActionGroupActionStateChangedCallback -> m SignalHandlerId+onActionGroupActionStateChanged obj cb = liftIO $ connectActionGroupActionStateChanged obj cb SignalConnectBefore+afterActionGroupActionStateChanged :: (GObject a, MonadIO m) => a -> ActionGroupActionStateChangedCallback -> m SignalHandlerId+afterActionGroupActionStateChanged obj cb = connectActionGroupActionStateChanged obj cb SignalConnectAfter++connectActionGroupActionStateChanged :: (GObject a, MonadIO m) =>+                                        a -> ActionGroupActionStateChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectActionGroupActionStateChanged obj cb after = liftIO $ do+    cb' <- mkActionGroupActionStateChangedCallback (actionGroupActionStateChangedCallbackWrapper cb)+    connectSignalFunPtr obj "action-state-changed" cb' after++type instance AttributeList ActionGroup = ActionGroupAttributeList+type ActionGroupAttributeList = ('[ ] :: [(Symbol, *)])++data ActionGroupActionAddedSignalInfo+instance SignalInfo ActionGroupActionAddedSignalInfo where+    type HaskellCallbackType ActionGroupActionAddedSignalInfo = ActionGroupActionAddedCallback+    connectSignal _ = connectActionGroupActionAdded++data ActionGroupActionEnabledChangedSignalInfo+instance SignalInfo ActionGroupActionEnabledChangedSignalInfo where+    type HaskellCallbackType ActionGroupActionEnabledChangedSignalInfo = ActionGroupActionEnabledChangedCallback+    connectSignal _ = connectActionGroupActionEnabledChanged++data ActionGroupActionRemovedSignalInfo+instance SignalInfo ActionGroupActionRemovedSignalInfo where+    type HaskellCallbackType ActionGroupActionRemovedSignalInfo = ActionGroupActionRemovedCallback+    connectSignal _ = connectActionGroupActionRemoved++data ActionGroupActionStateChangedSignalInfo+instance SignalInfo ActionGroupActionStateChangedSignalInfo where+    type HaskellCallbackType ActionGroupActionStateChangedSignalInfo = ActionGroupActionStateChangedCallback+    connectSignal _ = connectActionGroupActionStateChanged++type instance SignalList ActionGroup = ActionGroupSignalList+type ActionGroupSignalList = ('[ '("action-added", ActionGroupActionAddedSignalInfo), '("action-enabled-changed", ActionGroupActionEnabledChangedSignalInfo), '("action-removed", ActionGroupActionRemovedSignalInfo), '("action-state-changed", ActionGroupActionStateChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "g_action_group_get_type"+    c_g_action_group_get_type :: IO GType++type instance ParentTypes ActionGroup = ActionGroupParentTypes+type ActionGroupParentTypes = '[GObject.Object]++instance GObject ActionGroup where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_action_group_get_type+    ++class GObject o => ActionGroupK o+instance (GObject o, IsDescendantOf ActionGroup o) => ActionGroupK o++toActionGroup :: ActionGroupK o => o -> IO ActionGroup+toActionGroup = unsafeCastTo ActionGroup++-- method ActionGroup::action_added+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_action_group_action_added" g_action_group_action_added :: +    Ptr ActionGroup ->                      -- _obj : TInterface "Gio" "ActionGroup"+    CString ->                              -- action_name : TBasicType TUTF8+    IO ()+++actionGroupActionAdded ::+    (MonadIO m, ActionGroupK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- action_name+    m ()+actionGroupActionAdded _obj action_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    action_name' <- textToCString action_name+    g_action_group_action_added _obj' action_name'+    touchManagedPtr _obj+    freeMem action_name'+    return ()++-- method ActionGroup::action_enabled_changed+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_action_group_action_enabled_changed" g_action_group_action_enabled_changed :: +    Ptr ActionGroup ->                      -- _obj : TInterface "Gio" "ActionGroup"+    CString ->                              -- action_name : TBasicType TUTF8+    CInt ->                                 -- enabled : TBasicType TBoolean+    IO ()+++actionGroupActionEnabledChanged ::+    (MonadIO m, ActionGroupK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- action_name+    Bool ->                                 -- enabled+    m ()+actionGroupActionEnabledChanged _obj action_name enabled = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    action_name' <- textToCString action_name+    let enabled' = (fromIntegral . fromEnum) enabled+    g_action_group_action_enabled_changed _obj' action_name' enabled'+    touchManagedPtr _obj+    freeMem action_name'+    return ()++-- method ActionGroup::action_removed+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_action_group_action_removed" g_action_group_action_removed :: +    Ptr ActionGroup ->                      -- _obj : TInterface "Gio" "ActionGroup"+    CString ->                              -- action_name : TBasicType TUTF8+    IO ()+++actionGroupActionRemoved ::+    (MonadIO m, ActionGroupK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- action_name+    m ()+actionGroupActionRemoved _obj action_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    action_name' <- textToCString action_name+    g_action_group_action_removed _obj' action_name'+    touchManagedPtr _obj+    freeMem action_name'+    return ()++-- method ActionGroup::action_state_changed+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state", argType = TVariant, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state", argType = TVariant, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_action_group_action_state_changed" g_action_group_action_state_changed :: +    Ptr ActionGroup ->                      -- _obj : TInterface "Gio" "ActionGroup"+    CString ->                              -- action_name : TBasicType TUTF8+    Ptr GVariant ->                         -- state : TVariant+    IO ()+++actionGroupActionStateChanged ::+    (MonadIO m, ActionGroupK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- action_name+    GVariant ->                             -- state+    m ()+actionGroupActionStateChanged _obj action_name state = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    action_name' <- textToCString action_name+    let state' = unsafeManagedPtrGetPtr state+    g_action_group_action_state_changed _obj' action_name' state'+    touchManagedPtr _obj+    freeMem action_name'+    return ()++-- method ActionGroup::activate_action+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameter", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameter", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_action_group_activate_action" g_action_group_activate_action :: +    Ptr ActionGroup ->                      -- _obj : TInterface "Gio" "ActionGroup"+    CString ->                              -- action_name : TBasicType TUTF8+    Ptr GVariant ->                         -- parameter : TVariant+    IO ()+++actionGroupActivateAction ::+    (MonadIO m, ActionGroupK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- action_name+    Maybe (GVariant) ->                     -- parameter+    m ()+actionGroupActivateAction _obj action_name parameter = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    action_name' <- textToCString action_name+    maybeParameter <- case parameter of+        Nothing -> return nullPtr+        Just jParameter -> do+            let jParameter' = unsafeManagedPtrGetPtr jParameter+            return jParameter'+    g_action_group_activate_action _obj' action_name' maybeParameter+    touchManagedPtr _obj+    freeMem action_name'+    return ()++-- method ActionGroup::change_action_state+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TVariant, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TVariant, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_action_group_change_action_state" g_action_group_change_action_state :: +    Ptr ActionGroup ->                      -- _obj : TInterface "Gio" "ActionGroup"+    CString ->                              -- action_name : TBasicType TUTF8+    Ptr GVariant ->                         -- value : TVariant+    IO ()+++actionGroupChangeActionState ::+    (MonadIO m, ActionGroupK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- action_name+    GVariant ->                             -- value+    m ()+actionGroupChangeActionState _obj action_name value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    action_name' <- textToCString action_name+    let value' = unsafeManagedPtrGetPtr value+    g_action_group_change_action_state _obj' action_name' value'+    touchManagedPtr _obj+    freeMem action_name'+    return ()++-- method ActionGroup::get_action_enabled+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_action_group_get_action_enabled" g_action_group_get_action_enabled :: +    Ptr ActionGroup ->                      -- _obj : TInterface "Gio" "ActionGroup"+    CString ->                              -- action_name : TBasicType TUTF8+    IO CInt+++actionGroupGetActionEnabled ::+    (MonadIO m, ActionGroupK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- action_name+    m Bool+actionGroupGetActionEnabled _obj action_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    action_name' <- textToCString action_name+    result <- g_action_group_get_action_enabled _obj' action_name'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem action_name'+    return result'++-- method ActionGroup::get_action_parameter_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GLib" "VariantType"+-- throws : False+-- Skip return : False++foreign import ccall "g_action_group_get_action_parameter_type" g_action_group_get_action_parameter_type :: +    Ptr ActionGroup ->                      -- _obj : TInterface "Gio" "ActionGroup"+    CString ->                              -- action_name : TBasicType TUTF8+    IO (Ptr GLib.VariantType)+++actionGroupGetActionParameterType ::+    (MonadIO m, ActionGroupK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- action_name+    m GLib.VariantType+actionGroupGetActionParameterType _obj action_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    action_name' <- textToCString action_name+    result <- g_action_group_get_action_parameter_type _obj' action_name'+    checkUnexpectedReturnNULL "g_action_group_get_action_parameter_type" result+    result' <- (newBoxed GLib.VariantType) result+    touchManagedPtr _obj+    freeMem action_name'+    return result'++-- method ActionGroup::get_action_state+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TVariant+-- throws : False+-- Skip return : False++foreign import ccall "g_action_group_get_action_state" g_action_group_get_action_state :: +    Ptr ActionGroup ->                      -- _obj : TInterface "Gio" "ActionGroup"+    CString ->                              -- action_name : TBasicType TUTF8+    IO (Ptr GVariant)+++actionGroupGetActionState ::+    (MonadIO m, ActionGroupK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- action_name+    m GVariant+actionGroupGetActionState _obj action_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    action_name' <- textToCString action_name+    result <- g_action_group_get_action_state _obj' action_name'+    checkUnexpectedReturnNULL "g_action_group_get_action_state" result+    result' <- wrapGVariantPtr result+    touchManagedPtr _obj+    freeMem action_name'+    return result'++-- method ActionGroup::get_action_state_hint+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TVariant+-- throws : False+-- Skip return : False++foreign import ccall "g_action_group_get_action_state_hint" g_action_group_get_action_state_hint :: +    Ptr ActionGroup ->                      -- _obj : TInterface "Gio" "ActionGroup"+    CString ->                              -- action_name : TBasicType TUTF8+    IO (Ptr GVariant)+++actionGroupGetActionStateHint ::+    (MonadIO m, ActionGroupK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- action_name+    m GVariant+actionGroupGetActionStateHint _obj action_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    action_name' <- textToCString action_name+    result <- g_action_group_get_action_state_hint _obj' action_name'+    checkUnexpectedReturnNULL "g_action_group_get_action_state_hint" result+    result' <- wrapGVariantPtr result+    touchManagedPtr _obj+    freeMem action_name'+    return result'++-- method ActionGroup::get_action_state_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GLib" "VariantType"+-- throws : False+-- Skip return : False++foreign import ccall "g_action_group_get_action_state_type" g_action_group_get_action_state_type :: +    Ptr ActionGroup ->                      -- _obj : TInterface "Gio" "ActionGroup"+    CString ->                              -- action_name : TBasicType TUTF8+    IO (Ptr GLib.VariantType)+++actionGroupGetActionStateType ::+    (MonadIO m, ActionGroupK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- action_name+    m GLib.VariantType+actionGroupGetActionStateType _obj action_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    action_name' <- textToCString action_name+    result <- g_action_group_get_action_state_type _obj' action_name'+    checkUnexpectedReturnNULL "g_action_group_get_action_state_type" result+    result' <- (newBoxed GLib.VariantType) result+    touchManagedPtr _obj+    freeMem action_name'+    return result'++-- method ActionGroup::has_action+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_action_group_has_action" g_action_group_has_action :: +    Ptr ActionGroup ->                      -- _obj : TInterface "Gio" "ActionGroup"+    CString ->                              -- action_name : TBasicType TUTF8+    IO CInt+++actionGroupHasAction ::+    (MonadIO m, ActionGroupK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- action_name+    m Bool+actionGroupHasAction _obj action_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    action_name' <- textToCString action_name+    result <- g_action_group_has_action _obj' action_name'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem action_name'+    return result'++-- method ActionGroup::list_actions+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_action_group_list_actions" g_action_group_list_actions :: +    Ptr ActionGroup ->                      -- _obj : TInterface "Gio" "ActionGroup"+    IO (Ptr CString)+++actionGroupListActions ::+    (MonadIO m, ActionGroupK a) =>+    a ->                                    -- _obj+    m [T.Text]+actionGroupListActions _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_action_group_list_actions _obj'+    checkUnexpectedReturnNULL "g_action_group_list_actions" result+    result' <- unpackZeroTerminatedUTF8CArray result+    mapZeroTerminatedCArray freeMem result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method ActionGroup::query_action+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "enabled", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "parameter_type", argType = TInterface "GLib" "VariantType", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "state_type", argType = TInterface "GLib" "VariantType", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "state_hint", argType = TVariant, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "state", argType = TVariant, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_action_group_query_action" g_action_group_query_action :: +    Ptr ActionGroup ->                      -- _obj : TInterface "Gio" "ActionGroup"+    CString ->                              -- action_name : TBasicType TUTF8+    Ptr CInt ->                             -- enabled : TBasicType TBoolean+    Ptr (Ptr GLib.VariantType) ->           -- parameter_type : TInterface "GLib" "VariantType"+    Ptr (Ptr GLib.VariantType) ->           -- state_type : TInterface "GLib" "VariantType"+    Ptr (Ptr GVariant) ->                   -- state_hint : TVariant+    Ptr (Ptr GVariant) ->                   -- state : TVariant+    IO CInt+++actionGroupQueryAction ::+    (MonadIO m, ActionGroupK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- action_name+    m (Bool,Bool,GLib.VariantType,GLib.VariantType,GVariant,GVariant)+actionGroupQueryAction _obj action_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    action_name' <- textToCString action_name+    enabled <- allocMem :: IO (Ptr CInt)+    parameter_type <- allocMem :: IO (Ptr (Ptr GLib.VariantType))+    state_type <- allocMem :: IO (Ptr (Ptr GLib.VariantType))+    state_hint <- allocMem :: IO (Ptr (Ptr GVariant))+    state <- allocMem :: IO (Ptr (Ptr GVariant))+    result <- g_action_group_query_action _obj' action_name' enabled parameter_type state_type state_hint state+    let result' = (/= 0) result+    enabled' <- peek enabled+    let enabled'' = (/= 0) enabled'+    parameter_type' <- peek parameter_type+    parameter_type'' <- (wrapBoxed GLib.VariantType) parameter_type'+    state_type' <- peek state_type+    state_type'' <- (wrapBoxed GLib.VariantType) state_type'+    state_hint' <- peek state_hint+    state_hint'' <- wrapGVariantPtr state_hint'+    state' <- peek state+    state'' <- wrapGVariantPtr state'+    touchManagedPtr _obj+    freeMem action_name'+    freeMem enabled+    freeMem parameter_type+    freeMem state_type+    freeMem state_hint+    freeMem state+    return (result', enabled'', parameter_type'', state_type'', state_hint'', state'')++
+ GI/Gio/Interfaces/ActionGroup.hs-boot view
@@ -0,0 +1,17 @@+module GI.Gio.Interfaces.ActionGroup where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype ActionGroup = ActionGroup (ForeignPtr ActionGroup)+data ActionGroupActionAddedSignalInfo+data ActionGroupActionEnabledChangedSignalInfo+data ActionGroupActionRemovedSignalInfo+data ActionGroupActionStateChangedSignalInfo+instance GObject ActionGroup where+class GObject o => ActionGroupK o+instance (GObject o, IsDescendantOf ActionGroup o) => ActionGroupK o
+ GI/Gio/Interfaces/ActionMap.hs view
@@ -0,0 +1,199 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Interfaces.ActionMap+    ( ++-- * Exported types+    ActionMap(..)                           ,+    noActionMap                             ,+    ActionMapK                              ,+    toActionMap                             ,+++ -- * Methods+-- ** actionMapAddAction+    actionMapAddAction                      ,+++-- ** actionMapAddActionEntries+    actionMapAddActionEntries               ,+++-- ** actionMapLookupAction+    actionMapLookupAction                   ,+++-- ** actionMapRemoveAction+    actionMapRemoveAction                   ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++-- interface ActionMap ++newtype ActionMap = ActionMap (ForeignPtr ActionMap)+noActionMap :: Maybe ActionMap+noActionMap = Nothing++type instance AttributeList ActionMap = ActionMapAttributeList+type ActionMapAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList ActionMap = ActionMapSignalList+type ActionMapSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "g_action_map_get_type"+    c_g_action_map_get_type :: IO GType++type instance ParentTypes ActionMap = ActionMapParentTypes+type ActionMapParentTypes = '[GObject.Object]++instance GObject ActionMap where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_action_map_get_type+    ++class GObject o => ActionMapK o+instance (GObject o, IsDescendantOf ActionMap o) => ActionMapK o++toActionMap :: ActionMapK o => o -> IO ActionMap+toActionMap = unsafeCastTo ActionMap++-- method ActionMap::add_action+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionMap", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action", argType = TInterface "Gio" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionMap", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action", argType = TInterface "Gio" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_action_map_add_action" g_action_map_add_action :: +    Ptr ActionMap ->                        -- _obj : TInterface "Gio" "ActionMap"+    Ptr Action ->                           -- action : TInterface "Gio" "Action"+    IO ()+++actionMapAddAction ::+    (MonadIO m, ActionMapK a, ActionK b) =>+    a ->                                    -- _obj+    b ->                                    -- action+    m ()+actionMapAddAction _obj action = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let action' = unsafeManagedPtrCastPtr action+    g_action_map_add_action _obj' action'+    touchManagedPtr _obj+    touchManagedPtr action+    return ()++-- method ActionMap::add_action_entries+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionMap", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "entries", argType = TCArray False (-1) 2 (TInterface "Gio" "ActionEntry"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_entries", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "n_entries", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionMap", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "entries", argType = TCArray False (-1) 2 (TInterface "Gio" "ActionEntry"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_action_map_add_action_entries" g_action_map_add_action_entries :: +    Ptr ActionMap ->                        -- _obj : TInterface "Gio" "ActionMap"+    Ptr ActionEntry ->                      -- entries : TCArray False (-1) 2 (TInterface "Gio" "ActionEntry")+    Int32 ->                                -- n_entries : TBasicType TInt32+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++actionMapAddActionEntries ::+    (MonadIO m, ActionMapK a) =>+    a ->                                    -- _obj+    [ActionEntry] ->                        -- entries+    Ptr () ->                               -- user_data+    m ()+actionMapAddActionEntries _obj entries user_data = liftIO $ do+    let n_entries = fromIntegral $ length entries+    let _obj' = unsafeManagedPtrCastPtr _obj+    let entries' = map unsafeManagedPtrGetPtr entries+    entries'' <- packBlockArray 64 entries'+    g_action_map_add_action_entries _obj' entries'' n_entries user_data+    touchManagedPtr _obj+    mapM_ touchManagedPtr entries+    freeMem entries''+    return ()++-- method ActionMap::lookup_action+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionMap", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionMap", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Action"+-- throws : False+-- Skip return : False++foreign import ccall "g_action_map_lookup_action" g_action_map_lookup_action :: +    Ptr ActionMap ->                        -- _obj : TInterface "Gio" "ActionMap"+    CString ->                              -- action_name : TBasicType TUTF8+    IO (Ptr Action)+++actionMapLookupAction ::+    (MonadIO m, ActionMapK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- action_name+    m Action+actionMapLookupAction _obj action_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    action_name' <- textToCString action_name+    result <- g_action_map_lookup_action _obj' action_name'+    checkUnexpectedReturnNULL "g_action_map_lookup_action" result+    result' <- (newObject Action) result+    touchManagedPtr _obj+    freeMem action_name'+    return result'++-- method ActionMap::remove_action+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionMap", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ActionMap", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_action_map_remove_action" g_action_map_remove_action :: +    Ptr ActionMap ->                        -- _obj : TInterface "Gio" "ActionMap"+    CString ->                              -- action_name : TBasicType TUTF8+    IO ()+++actionMapRemoveAction ::+    (MonadIO m, ActionMapK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- action_name+    m ()+actionMapRemoveAction _obj action_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    action_name' <- textToCString action_name+    g_action_map_remove_action _obj' action_name'+    touchManagedPtr _obj+    freeMem action_name'+    return ()++
+ GI/Gio/Interfaces/ActionMap.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Interfaces.ActionMap where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype ActionMap = ActionMap (ForeignPtr ActionMap)+instance GObject ActionMap where+class GObject o => ActionMapK o+instance (GObject o, IsDescendantOf ActionMap o) => ActionMapK o
+ GI/Gio/Interfaces/AppInfo.hs view
@@ -0,0 +1,820 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Interfaces.AppInfo+    ( ++-- * Exported types+    AppInfo(..)                             ,+    noAppInfo                               ,+    AppInfoK                                ,+    toAppInfo                               ,+++ -- * Methods+-- ** appInfoAddSupportsType+    appInfoAddSupportsType                  ,+++-- ** appInfoCanDelete+    appInfoCanDelete                        ,+++-- ** appInfoCanRemoveSupportsType+    appInfoCanRemoveSupportsType            ,+++-- ** appInfoDelete+    appInfoDelete                           ,+++-- ** appInfoDup+    appInfoDup                              ,+++-- ** appInfoEqual+    appInfoEqual                            ,+++-- ** appInfoGetCommandline+    appInfoGetCommandline                   ,+++-- ** appInfoGetDescription+    appInfoGetDescription                   ,+++-- ** appInfoGetDisplayName+    appInfoGetDisplayName                   ,+++-- ** appInfoGetExecutable+    appInfoGetExecutable                    ,+++-- ** appInfoGetIcon+    appInfoGetIcon                          ,+++-- ** appInfoGetId+    appInfoGetId                            ,+++-- ** appInfoGetName+    appInfoGetName                          ,+++-- ** appInfoGetSupportedTypes+    appInfoGetSupportedTypes                ,+++-- ** appInfoLaunch+    appInfoLaunch                           ,+++-- ** appInfoLaunchUris+    appInfoLaunchUris                       ,+++-- ** appInfoRemoveSupportsType+    appInfoRemoveSupportsType               ,+++-- ** appInfoSetAsDefaultForExtension+    appInfoSetAsDefaultForExtension         ,+++-- ** appInfoSetAsDefaultForType+    appInfoSetAsDefaultForType              ,+++-- ** appInfoSetAsLastUsedForType+    appInfoSetAsLastUsedForType             ,+++-- ** appInfoShouldShow+    appInfoShouldShow                       ,+++-- ** appInfoSupportsFiles+    appInfoSupportsFiles                    ,+++-- ** appInfoSupportsUris+    appInfoSupportsUris                     ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++-- interface AppInfo ++newtype AppInfo = AppInfo (ForeignPtr AppInfo)+noAppInfo :: Maybe AppInfo+noAppInfo = Nothing++type instance AttributeList AppInfo = AppInfoAttributeList+type AppInfoAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList AppInfo = AppInfoSignalList+type AppInfoSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "g_app_info_get_type"+    c_g_app_info_get_type :: IO GType++type instance ParentTypes AppInfo = AppInfoParentTypes+type AppInfoParentTypes = '[GObject.Object]++instance GObject AppInfo where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_app_info_get_type+    ++class GObject o => AppInfoK o+instance (GObject o, IsDescendantOf AppInfo o) => AppInfoK o++toAppInfo :: AppInfoK o => o -> IO AppInfo+toAppInfo = unsafeCastTo AppInfo++-- method AppInfo::add_supports_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "content_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "content_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_app_info_add_supports_type" g_app_info_add_supports_type :: +    Ptr AppInfo ->                          -- _obj : TInterface "Gio" "AppInfo"+    CString ->                              -- content_type : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++appInfoAddSupportsType ::+    (MonadIO m, AppInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- content_type+    m ()+appInfoAddSupportsType _obj content_type = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    content_type' <- textToCString content_type+    onException (do+        _ <- propagateGError $ g_app_info_add_supports_type _obj' content_type'+        touchManagedPtr _obj+        freeMem content_type'+        return ()+     ) (do+        freeMem content_type'+     )++-- method AppInfo::can_delete+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_app_info_can_delete" g_app_info_can_delete :: +    Ptr AppInfo ->                          -- _obj : TInterface "Gio" "AppInfo"+    IO CInt+++appInfoCanDelete ::+    (MonadIO m, AppInfoK a) =>+    a ->                                    -- _obj+    m Bool+appInfoCanDelete _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_app_info_can_delete _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method AppInfo::can_remove_supports_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_app_info_can_remove_supports_type" g_app_info_can_remove_supports_type :: +    Ptr AppInfo ->                          -- _obj : TInterface "Gio" "AppInfo"+    IO CInt+++appInfoCanRemoveSupportsType ::+    (MonadIO m, AppInfoK a) =>+    a ->                                    -- _obj+    m Bool+appInfoCanRemoveSupportsType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_app_info_can_remove_supports_type _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method AppInfo::delete+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_app_info_delete" g_app_info_delete :: +    Ptr AppInfo ->                          -- _obj : TInterface "Gio" "AppInfo"+    IO CInt+++appInfoDelete ::+    (MonadIO m, AppInfoK a) =>+    a ->                                    -- _obj+    m Bool+appInfoDelete _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_app_info_delete _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method AppInfo::dup+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "AppInfo"+-- throws : False+-- Skip return : False++foreign import ccall "g_app_info_dup" g_app_info_dup :: +    Ptr AppInfo ->                          -- _obj : TInterface "Gio" "AppInfo"+    IO (Ptr AppInfo)+++appInfoDup ::+    (MonadIO m, AppInfoK a) =>+    a ->                                    -- _obj+    m AppInfo+appInfoDup _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_app_info_dup _obj'+    checkUnexpectedReturnNULL "g_app_info_dup" result+    result' <- (wrapObject AppInfo) result+    touchManagedPtr _obj+    return result'++-- method AppInfo::equal+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "appinfo2", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "appinfo2", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_app_info_equal" g_app_info_equal :: +    Ptr AppInfo ->                          -- _obj : TInterface "Gio" "AppInfo"+    Ptr AppInfo ->                          -- appinfo2 : TInterface "Gio" "AppInfo"+    IO CInt+++appInfoEqual ::+    (MonadIO m, AppInfoK a, AppInfoK b) =>+    a ->                                    -- _obj+    b ->                                    -- appinfo2+    m Bool+appInfoEqual _obj appinfo2 = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let appinfo2' = unsafeManagedPtrCastPtr appinfo2+    result <- g_app_info_equal _obj' appinfo2'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr appinfo2+    return result'++-- method AppInfo::get_commandline+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_app_info_get_commandline" g_app_info_get_commandline :: +    Ptr AppInfo ->                          -- _obj : TInterface "Gio" "AppInfo"+    IO CString+++appInfoGetCommandline ::+    (MonadIO m, AppInfoK a) =>+    a ->                                    -- _obj+    m T.Text+appInfoGetCommandline _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_app_info_get_commandline _obj'+    checkUnexpectedReturnNULL "g_app_info_get_commandline" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method AppInfo::get_description+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_app_info_get_description" g_app_info_get_description :: +    Ptr AppInfo ->                          -- _obj : TInterface "Gio" "AppInfo"+    IO CString+++appInfoGetDescription ::+    (MonadIO m, AppInfoK a) =>+    a ->                                    -- _obj+    m T.Text+appInfoGetDescription _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_app_info_get_description _obj'+    checkUnexpectedReturnNULL "g_app_info_get_description" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method AppInfo::get_display_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_app_info_get_display_name" g_app_info_get_display_name :: +    Ptr AppInfo ->                          -- _obj : TInterface "Gio" "AppInfo"+    IO CString+++appInfoGetDisplayName ::+    (MonadIO m, AppInfoK a) =>+    a ->                                    -- _obj+    m T.Text+appInfoGetDisplayName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_app_info_get_display_name _obj'+    checkUnexpectedReturnNULL "g_app_info_get_display_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method AppInfo::get_executable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_app_info_get_executable" g_app_info_get_executable :: +    Ptr AppInfo ->                          -- _obj : TInterface "Gio" "AppInfo"+    IO CString+++appInfoGetExecutable ::+    (MonadIO m, AppInfoK a) =>+    a ->                                    -- _obj+    m T.Text+appInfoGetExecutable _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_app_info_get_executable _obj'+    checkUnexpectedReturnNULL "g_app_info_get_executable" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method AppInfo::get_icon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Icon"+-- throws : False+-- Skip return : False++foreign import ccall "g_app_info_get_icon" g_app_info_get_icon :: +    Ptr AppInfo ->                          -- _obj : TInterface "Gio" "AppInfo"+    IO (Ptr Icon)+++appInfoGetIcon ::+    (MonadIO m, AppInfoK a) =>+    a ->                                    -- _obj+    m Icon+appInfoGetIcon _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_app_info_get_icon _obj'+    checkUnexpectedReturnNULL "g_app_info_get_icon" result+    result' <- (newObject Icon) result+    touchManagedPtr _obj+    return result'++-- method AppInfo::get_id+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_app_info_get_id" g_app_info_get_id :: +    Ptr AppInfo ->                          -- _obj : TInterface "Gio" "AppInfo"+    IO CString+++appInfoGetId ::+    (MonadIO m, AppInfoK a) =>+    a ->                                    -- _obj+    m T.Text+appInfoGetId _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_app_info_get_id _obj'+    checkUnexpectedReturnNULL "g_app_info_get_id" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method AppInfo::get_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_app_info_get_name" g_app_info_get_name :: +    Ptr AppInfo ->                          -- _obj : TInterface "Gio" "AppInfo"+    IO CString+++appInfoGetName ::+    (MonadIO m, AppInfoK a) =>+    a ->                                    -- _obj+    m T.Text+appInfoGetName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_app_info_get_name _obj'+    checkUnexpectedReturnNULL "g_app_info_get_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method AppInfo::get_supported_types+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_app_info_get_supported_types" g_app_info_get_supported_types :: +    Ptr AppInfo ->                          -- _obj : TInterface "Gio" "AppInfo"+    IO (Ptr CString)+++appInfoGetSupportedTypes ::+    (MonadIO m, AppInfoK a) =>+    a ->                                    -- _obj+    m [T.Text]+appInfoGetSupportedTypes _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_app_info_get_supported_types _obj'+    checkUnexpectedReturnNULL "g_app_info_get_supported_types" result+    result' <- unpackZeroTerminatedUTF8CArray result+    touchManagedPtr _obj+    return result'++-- method AppInfo::launch+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "files", argType = TGList (TInterface "Gio" "File"), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "launch_context", argType = TInterface "Gio" "AppLaunchContext", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "files", argType = TGList (TInterface "Gio" "File"), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "launch_context", argType = TInterface "Gio" "AppLaunchContext", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_app_info_launch" g_app_info_launch :: +    Ptr AppInfo ->                          -- _obj : TInterface "Gio" "AppInfo"+    Ptr (GList (Ptr File)) ->               -- files : TGList (TInterface "Gio" "File")+    Ptr AppLaunchContext ->                 -- launch_context : TInterface "Gio" "AppLaunchContext"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++appInfoLaunch ::+    (MonadIO m, AppInfoK a, FileK b, AppLaunchContextK c) =>+    a ->                                    -- _obj+    [b] ->                                  -- files+    Maybe (c) ->                            -- launch_context+    m ()+appInfoLaunch _obj files launch_context = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let files' = map unsafeManagedPtrCastPtr files+    files'' <- packGList files'+    maybeLaunch_context <- case launch_context of+        Nothing -> return nullPtr+        Just jLaunch_context -> do+            let jLaunch_context' = unsafeManagedPtrCastPtr jLaunch_context+            return jLaunch_context'+    onException (do+        _ <- propagateGError $ g_app_info_launch _obj' files'' maybeLaunch_context+        touchManagedPtr _obj+        mapM_ touchManagedPtr files+        whenJust launch_context touchManagedPtr+        g_list_free files''+        return ()+     ) (do+        g_list_free files''+     )++-- method AppInfo::launch_uris+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "uris", argType = TGList (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "launch_context", argType = TInterface "Gio" "AppLaunchContext", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "uris", argType = TGList (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "launch_context", argType = TInterface "Gio" "AppLaunchContext", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_app_info_launch_uris" g_app_info_launch_uris :: +    Ptr AppInfo ->                          -- _obj : TInterface "Gio" "AppInfo"+    Ptr (GList CString) ->                  -- uris : TGList (TBasicType TUTF8)+    Ptr AppLaunchContext ->                 -- launch_context : TInterface "Gio" "AppLaunchContext"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++appInfoLaunchUris ::+    (MonadIO m, AppInfoK a, AppLaunchContextK b) =>+    a ->                                    -- _obj+    [T.Text] ->                             -- uris+    Maybe (b) ->                            -- launch_context+    m ()+appInfoLaunchUris _obj uris launch_context = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    uris' <- mapM textToCString uris+    uris'' <- packGList uris'+    maybeLaunch_context <- case launch_context of+        Nothing -> return nullPtr+        Just jLaunch_context -> do+            let jLaunch_context' = unsafeManagedPtrCastPtr jLaunch_context+            return jLaunch_context'+    onException (do+        _ <- propagateGError $ g_app_info_launch_uris _obj' uris'' maybeLaunch_context+        touchManagedPtr _obj+        whenJust launch_context touchManagedPtr+        mapGList freeMem uris''+        g_list_free uris''+        return ()+     ) (do+        mapGList freeMem uris''+        g_list_free uris''+     )++-- method AppInfo::remove_supports_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "content_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "content_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_app_info_remove_supports_type" g_app_info_remove_supports_type :: +    Ptr AppInfo ->                          -- _obj : TInterface "Gio" "AppInfo"+    CString ->                              -- content_type : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++appInfoRemoveSupportsType ::+    (MonadIO m, AppInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- content_type+    m ()+appInfoRemoveSupportsType _obj content_type = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    content_type' <- textToCString content_type+    onException (do+        _ <- propagateGError $ g_app_info_remove_supports_type _obj' content_type'+        touchManagedPtr _obj+        freeMem content_type'+        return ()+     ) (do+        freeMem content_type'+     )++-- method AppInfo::set_as_default_for_extension+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "extension", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "extension", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_app_info_set_as_default_for_extension" g_app_info_set_as_default_for_extension :: +    Ptr AppInfo ->                          -- _obj : TInterface "Gio" "AppInfo"+    CString ->                              -- extension : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++appInfoSetAsDefaultForExtension ::+    (MonadIO m, AppInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- extension+    m ()+appInfoSetAsDefaultForExtension _obj extension = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    extension' <- textToCString extension+    onException (do+        _ <- propagateGError $ g_app_info_set_as_default_for_extension _obj' extension'+        touchManagedPtr _obj+        freeMem extension'+        return ()+     ) (do+        freeMem extension'+     )++-- method AppInfo::set_as_default_for_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "content_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "content_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_app_info_set_as_default_for_type" g_app_info_set_as_default_for_type :: +    Ptr AppInfo ->                          -- _obj : TInterface "Gio" "AppInfo"+    CString ->                              -- content_type : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++appInfoSetAsDefaultForType ::+    (MonadIO m, AppInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- content_type+    m ()+appInfoSetAsDefaultForType _obj content_type = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    content_type' <- textToCString content_type+    onException (do+        _ <- propagateGError $ g_app_info_set_as_default_for_type _obj' content_type'+        touchManagedPtr _obj+        freeMem content_type'+        return ()+     ) (do+        freeMem content_type'+     )++-- method AppInfo::set_as_last_used_for_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "content_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "content_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_app_info_set_as_last_used_for_type" g_app_info_set_as_last_used_for_type :: +    Ptr AppInfo ->                          -- _obj : TInterface "Gio" "AppInfo"+    CString ->                              -- content_type : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++appInfoSetAsLastUsedForType ::+    (MonadIO m, AppInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- content_type+    m ()+appInfoSetAsLastUsedForType _obj content_type = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    content_type' <- textToCString content_type+    onException (do+        _ <- propagateGError $ g_app_info_set_as_last_used_for_type _obj' content_type'+        touchManagedPtr _obj+        freeMem content_type'+        return ()+     ) (do+        freeMem content_type'+     )++-- method AppInfo::should_show+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_app_info_should_show" g_app_info_should_show :: +    Ptr AppInfo ->                          -- _obj : TInterface "Gio" "AppInfo"+    IO CInt+++appInfoShouldShow ::+    (MonadIO m, AppInfoK a) =>+    a ->                                    -- _obj+    m Bool+appInfoShouldShow _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_app_info_should_show _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method AppInfo::supports_files+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_app_info_supports_files" g_app_info_supports_files :: +    Ptr AppInfo ->                          -- _obj : TInterface "Gio" "AppInfo"+    IO CInt+++appInfoSupportsFiles ::+    (MonadIO m, AppInfoK a) =>+    a ->                                    -- _obj+    m Bool+appInfoSupportsFiles _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_app_info_supports_files _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method AppInfo::supports_uris+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_app_info_supports_uris" g_app_info_supports_uris :: +    Ptr AppInfo ->                          -- _obj : TInterface "Gio" "AppInfo"+    IO CInt+++appInfoSupportsUris ::+    (MonadIO m, AppInfoK a) =>+    a ->                                    -- _obj+    m Bool+appInfoSupportsUris _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_app_info_supports_uris _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++
+ GI/Gio/Interfaces/AppInfo.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Interfaces.AppInfo where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype AppInfo = AppInfo (ForeignPtr AppInfo)+instance GObject AppInfo where+class GObject o => AppInfoK o+instance (GObject o, IsDescendantOf AppInfo o) => AppInfoK o
+ GI/Gio/Interfaces/AsyncInitable.hs view
@@ -0,0 +1,188 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Interfaces.AsyncInitable+    ( ++-- * Exported types+    AsyncInitable(..)                       ,+    noAsyncInitable                         ,+    AsyncInitableK                          ,+    toAsyncInitable                         ,+++ -- * Methods+-- ** asyncInitableInitAsync+    asyncInitableInitAsync                  ,+++-- ** asyncInitableInitFinish+    asyncInitableInitFinish                 ,+++-- ** asyncInitableNewFinish+    asyncInitableNewFinish                  ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++-- interface AsyncInitable ++newtype AsyncInitable = AsyncInitable (ForeignPtr AsyncInitable)+noAsyncInitable :: Maybe AsyncInitable+noAsyncInitable = Nothing++type instance AttributeList AsyncInitable = AsyncInitableAttributeList+type AsyncInitableAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList AsyncInitable = AsyncInitableSignalList+type AsyncInitableSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "g_async_initable_get_type"+    c_g_async_initable_get_type :: IO GType++type instance ParentTypes AsyncInitable = AsyncInitableParentTypes+type AsyncInitableParentTypes = '[GObject.Object]++instance GObject AsyncInitable where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_async_initable_get_type+    ++class GObject o => AsyncInitableK o+instance (GObject o, IsDescendantOf AsyncInitable o) => AsyncInitableK o++toAsyncInitable :: AsyncInitableK o => o -> IO AsyncInitable+toAsyncInitable = unsafeCastTo AsyncInitable++-- method AsyncInitable::init_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AsyncInitable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AsyncInitable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_async_initable_init_async" g_async_initable_init_async :: +    Ptr AsyncInitable ->                    -- _obj : TInterface "Gio" "AsyncInitable"+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++asyncInitableInitAsync ::+    (MonadIO m, AsyncInitableK a, CancellableK b) =>+    a ->                                    -- _obj+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+asyncInitableInitAsync _obj io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_async_initable_init_async _obj' io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method AsyncInitable::init_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AsyncInitable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AsyncInitable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_async_initable_init_finish" g_async_initable_init_finish :: +    Ptr AsyncInitable ->                    -- _obj : TInterface "Gio" "AsyncInitable"+    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++asyncInitableInitFinish ::+    (MonadIO m, AsyncInitableK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- res+    m ()+asyncInitableInitFinish _obj res = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let res' = unsafeManagedPtrCastPtr res+    onException (do+        _ <- propagateGError $ g_async_initable_init_finish _obj' res'+        touchManagedPtr _obj+        touchManagedPtr res+        return ()+     ) (do+        return ()+     )++-- method AsyncInitable::new_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AsyncInitable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AsyncInitable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GObject" "Object"+-- throws : True+-- Skip return : False++foreign import ccall "g_async_initable_new_finish" g_async_initable_new_finish :: +    Ptr AsyncInitable ->                    -- _obj : TInterface "Gio" "AsyncInitable"+    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr GObject.Object)+++asyncInitableNewFinish ::+    (MonadIO m, AsyncInitableK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- res+    m GObject.Object+asyncInitableNewFinish _obj res = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let res' = unsafeManagedPtrCastPtr res+    onException (do+        result <- propagateGError $ g_async_initable_new_finish _obj' res'+        checkUnexpectedReturnNULL "g_async_initable_new_finish" result+        result' <- (wrapObject GObject.Object) result+        touchManagedPtr _obj+        touchManagedPtr res+        return result'+     ) (do+        return ()+     )++
+ GI/Gio/Interfaces/AsyncInitable.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Interfaces.AsyncInitable where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype AsyncInitable = AsyncInitable (ForeignPtr AsyncInitable)+instance GObject AsyncInitable where+class GObject o => AsyncInitableK o+instance (GObject o, IsDescendantOf AsyncInitable o) => AsyncInitableK o
+ GI/Gio/Interfaces/AsyncResult.hs view
@@ -0,0 +1,185 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Interfaces.AsyncResult+    ( ++-- * Exported types+    AsyncResult(..)                         ,+    noAsyncResult                           ,+    AsyncResultK                            ,+    toAsyncResult                           ,+++ -- * Methods+-- ** asyncResultGetSourceObject+    asyncResultGetSourceObject              ,+++-- ** asyncResultGetUserData+    asyncResultGetUserData                  ,+++-- ** asyncResultIsTagged+    asyncResultIsTagged                     ,+++-- ** asyncResultLegacyPropagateError+    asyncResultLegacyPropagateError         ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++-- interface AsyncResult ++newtype AsyncResult = AsyncResult (ForeignPtr AsyncResult)+noAsyncResult :: Maybe AsyncResult+noAsyncResult = Nothing++type instance AttributeList AsyncResult = AsyncResultAttributeList+type AsyncResultAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList AsyncResult = AsyncResultSignalList+type AsyncResultSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "g_async_result_get_type"+    c_g_async_result_get_type :: IO GType++type instance ParentTypes AsyncResult = AsyncResultParentTypes+type AsyncResultParentTypes = '[GObject.Object]++instance GObject AsyncResult where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_async_result_get_type+    ++class GObject o => AsyncResultK o+instance (GObject o, IsDescendantOf AsyncResult o) => AsyncResultK o++toAsyncResult :: AsyncResultK o => o -> IO AsyncResult+toAsyncResult = unsafeCastTo AsyncResult++-- method AsyncResult::get_source_object+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GObject" "Object"+-- throws : False+-- Skip return : False++foreign import ccall "g_async_result_get_source_object" g_async_result_get_source_object :: +    Ptr AsyncResult ->                      -- _obj : TInterface "Gio" "AsyncResult"+    IO (Ptr GObject.Object)+++asyncResultGetSourceObject ::+    (MonadIO m, AsyncResultK a) =>+    a ->                                    -- _obj+    m GObject.Object+asyncResultGetSourceObject _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_async_result_get_source_object _obj'+    checkUnexpectedReturnNULL "g_async_result_get_source_object" result+    result' <- (wrapObject GObject.Object) result+    touchManagedPtr _obj+    return result'++-- method AsyncResult::get_user_data+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_async_result_get_user_data" g_async_result_get_user_data :: +    Ptr AsyncResult ->                      -- _obj : TInterface "Gio" "AsyncResult"+    IO ()+++asyncResultGetUserData ::+    (MonadIO m, AsyncResultK a) =>+    a ->                                    -- _obj+    m ()+asyncResultGetUserData _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_async_result_get_user_data _obj'+    touchManagedPtr _obj+    return ()++-- method AsyncResult::is_tagged+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source_tag", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source_tag", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_async_result_is_tagged" g_async_result_is_tagged :: +    Ptr AsyncResult ->                      -- _obj : TInterface "Gio" "AsyncResult"+    Ptr () ->                               -- source_tag : TBasicType TVoid+    IO CInt+++asyncResultIsTagged ::+    (MonadIO m, AsyncResultK a) =>+    a ->                                    -- _obj+    Ptr () ->                               -- source_tag+    m Bool+asyncResultIsTagged _obj source_tag = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_async_result_is_tagged _obj' source_tag+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method AsyncResult::legacy_propagate_error+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_async_result_legacy_propagate_error" g_async_result_legacy_propagate_error :: +    Ptr AsyncResult ->                      -- _obj : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++asyncResultLegacyPropagateError ::+    (MonadIO m, AsyncResultK a) =>+    a ->                                    -- _obj+    m ()+asyncResultLegacyPropagateError _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    onException (do+        _ <- propagateGError $ g_async_result_legacy_propagate_error _obj'+        touchManagedPtr _obj+        return ()+     ) (do+        return ()+     )++
+ GI/Gio/Interfaces/AsyncResult.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Interfaces.AsyncResult where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype AsyncResult = AsyncResult (ForeignPtr AsyncResult)+instance GObject AsyncResult where+class GObject o => AsyncResultK o+instance (GObject o, IsDescendantOf AsyncResult o) => AsyncResultK o
+ GI/Gio/Interfaces/Converter.hs view
@@ -0,0 +1,148 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Interfaces.Converter+    ( ++-- * Exported types+    Converter(..)                           ,+    noConverter                             ,+    ConverterK                              ,+    toConverter                             ,+++ -- * Methods+-- ** converterConvert+    converterConvert                        ,+++-- ** converterReset+    converterReset                          ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++-- interface Converter ++newtype Converter = Converter (ForeignPtr Converter)+noConverter :: Maybe Converter+noConverter = Nothing++type instance AttributeList Converter = ConverterAttributeList+type ConverterAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList Converter = ConverterSignalList+type ConverterSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "g_converter_get_type"+    c_g_converter_get_type :: IO GType++type instance ParentTypes Converter = ConverterParentTypes+type ConverterParentTypes = '[GObject.Object]++instance GObject Converter where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_converter_get_type+    ++class GObject o => ConverterK o+instance (GObject o, IsDescendantOf Converter o) => ConverterK o++toConverter :: ConverterK o => o -> IO Converter+toConverter = unsafeCastTo Converter++-- method Converter::convert+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Converter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "inbuf", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "inbuf_size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "outbuf", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "outbuf_size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "ConverterFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "bytes_read", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "bytes_written", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : [Arg {argName = "inbuf_size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Converter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "inbuf", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "outbuf", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "outbuf_size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "ConverterFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "ConverterResult"+-- throws : True+-- Skip return : False++foreign import ccall "g_converter_convert" g_converter_convert :: +    Ptr Converter ->                        -- _obj : TInterface "Gio" "Converter"+    Ptr Word8 ->                            -- inbuf : TCArray False (-1) 2 (TBasicType TUInt8)+    Word64 ->                               -- inbuf_size : TBasicType TUInt64+    Ptr () ->                               -- outbuf : TBasicType TVoid+    Word64 ->                               -- outbuf_size : TBasicType TUInt64+    CUInt ->                                -- flags : TInterface "Gio" "ConverterFlags"+    Ptr Word64 ->                           -- bytes_read : TBasicType TUInt64+    Ptr Word64 ->                           -- bytes_written : TBasicType TUInt64+    Ptr (Ptr GError) ->                     -- error+    IO CUInt+++converterConvert ::+    (MonadIO m, ConverterK a) =>+    a ->                                    -- _obj+    ByteString ->                           -- inbuf+    Ptr () ->                               -- outbuf+    Word64 ->                               -- outbuf_size+    [ConverterFlags] ->                     -- flags+    m (ConverterResult,Word64,Word64)+converterConvert _obj inbuf outbuf outbuf_size flags = liftIO $ do+    let inbuf_size = fromIntegral $ B.length inbuf+    let _obj' = unsafeManagedPtrCastPtr _obj+    inbuf' <- packByteString inbuf+    let flags' = gflagsToWord flags+    bytes_read <- allocMem :: IO (Ptr Word64)+    bytes_written <- allocMem :: IO (Ptr Word64)+    onException (do+        result <- propagateGError $ g_converter_convert _obj' inbuf' inbuf_size outbuf outbuf_size flags' bytes_read bytes_written+        let result' = (toEnum . fromIntegral) result+        bytes_read' <- peek bytes_read+        bytes_written' <- peek bytes_written+        touchManagedPtr _obj+        freeMem inbuf'+        freeMem bytes_read+        freeMem bytes_written+        return (result', bytes_read', bytes_written')+     ) (do+        freeMem inbuf'+        freeMem bytes_read+        freeMem bytes_written+     )++-- method Converter::reset+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Converter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Converter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_converter_reset" g_converter_reset :: +    Ptr Converter ->                        -- _obj : TInterface "Gio" "Converter"+    IO ()+++converterReset ::+    (MonadIO m, ConverterK a) =>+    a ->                                    -- _obj+    m ()+converterReset _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_converter_reset _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Interfaces/Converter.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Interfaces.Converter where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Converter = Converter (ForeignPtr Converter)+instance GObject Converter where+class GObject o => ConverterK o+instance (GObject o, IsDescendantOf Converter o) => ConverterK o
+ GI/Gio/Interfaces/DBusInterface.hs view
@@ -0,0 +1,159 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Interfaces.DBusInterface+    ( ++-- * Exported types+    DBusInterface(..)                       ,+    noDBusInterface                         ,+    DBusInterfaceK                          ,+    toDBusInterface                         ,+++ -- * Methods+-- ** dBusInterfaceGetInfo+    dBusInterfaceGetInfo                    ,+++-- ** dBusInterfaceGetObject+    dBusInterfaceGetObject                  ,+++-- ** dBusInterfaceSetObject+    dBusInterfaceSetObject                  ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++-- interface DBusInterface ++newtype DBusInterface = DBusInterface (ForeignPtr DBusInterface)+noDBusInterface :: Maybe DBusInterface+noDBusInterface = Nothing++type instance AttributeList DBusInterface = DBusInterfaceAttributeList+type DBusInterfaceAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList DBusInterface = DBusInterfaceSignalList+type DBusInterfaceSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "g_dbus_interface_get_type"+    c_g_dbus_interface_get_type :: IO GType++type instance ParentTypes DBusInterface = DBusInterfaceParentTypes+type DBusInterfaceParentTypes = '[GObject.Object]++instance GObject DBusInterface where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_dbus_interface_get_type+    ++class GObject o => DBusInterfaceK o+instance (GObject o, IsDescendantOf DBusInterface o) => DBusInterfaceK o++toDBusInterface :: DBusInterfaceK o => o -> IO DBusInterface+toDBusInterface = unsafeCastTo DBusInterface++-- method DBusInterface::get_object+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterface", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterface", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusObject"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_interface_dup_object" g_dbus_interface_dup_object :: +    Ptr DBusInterface ->                    -- _obj : TInterface "Gio" "DBusInterface"+    IO (Ptr DBusObject)+++dBusInterfaceGetObject ::+    (MonadIO m, DBusInterfaceK a) =>+    a ->                                    -- _obj+    m DBusObject+dBusInterfaceGetObject _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_interface_dup_object _obj'+    checkUnexpectedReturnNULL "g_dbus_interface_dup_object" result+    result' <- (wrapObject DBusObject) result+    touchManagedPtr _obj+    return result'++-- method DBusInterface::get_info+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterface", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterface", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusInterfaceInfo"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_interface_get_info" g_dbus_interface_get_info :: +    Ptr DBusInterface ->                    -- _obj : TInterface "Gio" "DBusInterface"+    IO (Ptr DBusInterfaceInfo)+++dBusInterfaceGetInfo ::+    (MonadIO m, DBusInterfaceK a) =>+    a ->                                    -- _obj+    m DBusInterfaceInfo+dBusInterfaceGetInfo _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_interface_get_info _obj'+    checkUnexpectedReturnNULL "g_dbus_interface_get_info" result+    result' <- (newBoxed DBusInterfaceInfo) result+    touchManagedPtr _obj+    return result'++-- method DBusInterface::set_object+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterface", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object", argType = TInterface "Gio" "DBusObject", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterface", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object", argType = TInterface "Gio" "DBusObject", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_interface_set_object" g_dbus_interface_set_object :: +    Ptr DBusInterface ->                    -- _obj : TInterface "Gio" "DBusInterface"+    Ptr DBusObject ->                       -- object : TInterface "Gio" "DBusObject"+    IO ()+++dBusInterfaceSetObject ::+    (MonadIO m, DBusInterfaceK a, DBusObjectK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- object+    m ()+dBusInterfaceSetObject _obj object = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeObject <- case object of+        Nothing -> return nullPtr+        Just jObject -> do+            let jObject' = unsafeManagedPtrCastPtr jObject+            return jObject'+    g_dbus_interface_set_object _obj' maybeObject+    touchManagedPtr _obj+    whenJust object touchManagedPtr+    return ()++
+ GI/Gio/Interfaces/DBusInterface.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Interfaces.DBusInterface where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype DBusInterface = DBusInterface (ForeignPtr DBusInterface)+instance GObject DBusInterface where+class GObject o => DBusInterfaceK o+instance (GObject o, IsDescendantOf DBusInterface o) => DBusInterfaceK o
+ GI/Gio/Interfaces/DBusObject.hs view
@@ -0,0 +1,280 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Interfaces.DBusObject+    ( ++-- * Exported types+    DBusObject(..)                          ,+    noDBusObject                            ,+    DBusObjectK                             ,+    toDBusObject                            ,+++ -- * Methods+-- ** dBusObjectGetInterface+    dBusObjectGetInterface                  ,+++-- ** dBusObjectGetInterfaces+    dBusObjectGetInterfaces                 ,+++-- ** dBusObjectGetObjectPath+    dBusObjectGetObjectPath                 ,+++++ -- * Signals+-- ** InterfaceAdded+    DBusObjectInterfaceAddedCallback        ,+    DBusObjectInterfaceAddedCallbackC       ,+    DBusObjectInterfaceAddedSignalInfo      ,+    afterDBusObjectInterfaceAdded           ,+    dBusObjectInterfaceAddedCallbackWrapper ,+    dBusObjectInterfaceAddedClosure         ,+    mkDBusObjectInterfaceAddedCallback      ,+    noDBusObjectInterfaceAddedCallback      ,+    onDBusObjectInterfaceAdded              ,+++-- ** InterfaceRemoved+    DBusObjectInterfaceRemovedCallback      ,+    DBusObjectInterfaceRemovedCallbackC     ,+    DBusObjectInterfaceRemovedSignalInfo    ,+    afterDBusObjectInterfaceRemoved         ,+    dBusObjectInterfaceRemovedCallbackWrapper,+    dBusObjectInterfaceRemovedClosure       ,+    mkDBusObjectInterfaceRemovedCallback    ,+    noDBusObjectInterfaceRemovedCallback    ,+    onDBusObjectInterfaceRemoved            ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++-- interface DBusObject ++newtype DBusObject = DBusObject (ForeignPtr DBusObject)+noDBusObject :: Maybe DBusObject+noDBusObject = Nothing++-- signal DBusObject::interface-added+type DBusObjectInterfaceAddedCallback =+    DBusInterface ->+    IO ()++noDBusObjectInterfaceAddedCallback :: Maybe DBusObjectInterfaceAddedCallback+noDBusObjectInterfaceAddedCallback = Nothing++type DBusObjectInterfaceAddedCallbackC =+    Ptr () ->                               -- object+    Ptr DBusInterface ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkDBusObjectInterfaceAddedCallback :: DBusObjectInterfaceAddedCallbackC -> IO (FunPtr DBusObjectInterfaceAddedCallbackC)++dBusObjectInterfaceAddedClosure :: DBusObjectInterfaceAddedCallback -> IO Closure+dBusObjectInterfaceAddedClosure cb = newCClosure =<< mkDBusObjectInterfaceAddedCallback wrapped+    where wrapped = dBusObjectInterfaceAddedCallbackWrapper cb++dBusObjectInterfaceAddedCallbackWrapper ::+    DBusObjectInterfaceAddedCallback ->+    Ptr () ->+    Ptr DBusInterface ->+    Ptr () ->+    IO ()+dBusObjectInterfaceAddedCallbackWrapper _cb _ interface _ = do+    interface' <- (newObject DBusInterface) interface+    _cb  interface'++onDBusObjectInterfaceAdded :: (GObject a, MonadIO m) => a -> DBusObjectInterfaceAddedCallback -> m SignalHandlerId+onDBusObjectInterfaceAdded obj cb = liftIO $ connectDBusObjectInterfaceAdded obj cb SignalConnectBefore+afterDBusObjectInterfaceAdded :: (GObject a, MonadIO m) => a -> DBusObjectInterfaceAddedCallback -> m SignalHandlerId+afterDBusObjectInterfaceAdded obj cb = connectDBusObjectInterfaceAdded obj cb SignalConnectAfter++connectDBusObjectInterfaceAdded :: (GObject a, MonadIO m) =>+                                   a -> DBusObjectInterfaceAddedCallback -> SignalConnectMode -> m SignalHandlerId+connectDBusObjectInterfaceAdded obj cb after = liftIO $ do+    cb' <- mkDBusObjectInterfaceAddedCallback (dBusObjectInterfaceAddedCallbackWrapper cb)+    connectSignalFunPtr obj "interface-added" cb' after++-- signal DBusObject::interface-removed+type DBusObjectInterfaceRemovedCallback =+    DBusInterface ->+    IO ()++noDBusObjectInterfaceRemovedCallback :: Maybe DBusObjectInterfaceRemovedCallback+noDBusObjectInterfaceRemovedCallback = Nothing++type DBusObjectInterfaceRemovedCallbackC =+    Ptr () ->                               -- object+    Ptr DBusInterface ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkDBusObjectInterfaceRemovedCallback :: DBusObjectInterfaceRemovedCallbackC -> IO (FunPtr DBusObjectInterfaceRemovedCallbackC)++dBusObjectInterfaceRemovedClosure :: DBusObjectInterfaceRemovedCallback -> IO Closure+dBusObjectInterfaceRemovedClosure cb = newCClosure =<< mkDBusObjectInterfaceRemovedCallback wrapped+    where wrapped = dBusObjectInterfaceRemovedCallbackWrapper cb++dBusObjectInterfaceRemovedCallbackWrapper ::+    DBusObjectInterfaceRemovedCallback ->+    Ptr () ->+    Ptr DBusInterface ->+    Ptr () ->+    IO ()+dBusObjectInterfaceRemovedCallbackWrapper _cb _ interface _ = do+    interface' <- (newObject DBusInterface) interface+    _cb  interface'++onDBusObjectInterfaceRemoved :: (GObject a, MonadIO m) => a -> DBusObjectInterfaceRemovedCallback -> m SignalHandlerId+onDBusObjectInterfaceRemoved obj cb = liftIO $ connectDBusObjectInterfaceRemoved obj cb SignalConnectBefore+afterDBusObjectInterfaceRemoved :: (GObject a, MonadIO m) => a -> DBusObjectInterfaceRemovedCallback -> m SignalHandlerId+afterDBusObjectInterfaceRemoved obj cb = connectDBusObjectInterfaceRemoved obj cb SignalConnectAfter++connectDBusObjectInterfaceRemoved :: (GObject a, MonadIO m) =>+                                     a -> DBusObjectInterfaceRemovedCallback -> SignalConnectMode -> m SignalHandlerId+connectDBusObjectInterfaceRemoved obj cb after = liftIO $ do+    cb' <- mkDBusObjectInterfaceRemovedCallback (dBusObjectInterfaceRemovedCallbackWrapper cb)+    connectSignalFunPtr obj "interface-removed" cb' after++type instance AttributeList DBusObject = DBusObjectAttributeList+type DBusObjectAttributeList = ('[ ] :: [(Symbol, *)])++data DBusObjectInterfaceAddedSignalInfo+instance SignalInfo DBusObjectInterfaceAddedSignalInfo where+    type HaskellCallbackType DBusObjectInterfaceAddedSignalInfo = DBusObjectInterfaceAddedCallback+    connectSignal _ = connectDBusObjectInterfaceAdded++data DBusObjectInterfaceRemovedSignalInfo+instance SignalInfo DBusObjectInterfaceRemovedSignalInfo where+    type HaskellCallbackType DBusObjectInterfaceRemovedSignalInfo = DBusObjectInterfaceRemovedCallback+    connectSignal _ = connectDBusObjectInterfaceRemoved++type instance SignalList DBusObject = DBusObjectSignalList+type DBusObjectSignalList = ('[ '("interface-added", DBusObjectInterfaceAddedSignalInfo), '("interface-removed", DBusObjectInterfaceRemovedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "g_dbus_object_get_type"+    c_g_dbus_object_get_type :: IO GType++type instance ParentTypes DBusObject = DBusObjectParentTypes+type DBusObjectParentTypes = '[GObject.Object]++instance GObject DBusObject where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_dbus_object_get_type+    ++class GObject o => DBusObjectK o+instance (GObject o, IsDescendantOf DBusObject o) => DBusObjectK o++toDBusObject :: DBusObjectK o => o -> IO DBusObject+toDBusObject = unsafeCastTo DBusObject++-- method DBusObject::get_interface+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObject", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObject", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusInterface"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_object_get_interface" g_dbus_object_get_interface :: +    Ptr DBusObject ->                       -- _obj : TInterface "Gio" "DBusObject"+    CString ->                              -- interface_name : TBasicType TUTF8+    IO (Ptr DBusInterface)+++dBusObjectGetInterface ::+    (MonadIO m, DBusObjectK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- interface_name+    m DBusInterface+dBusObjectGetInterface _obj interface_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    interface_name' <- textToCString interface_name+    result <- g_dbus_object_get_interface _obj' interface_name'+    checkUnexpectedReturnNULL "g_dbus_object_get_interface" result+    result' <- (wrapObject DBusInterface) result+    touchManagedPtr _obj+    freeMem interface_name'+    return result'++-- method DBusObject::get_interfaces+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObject", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObject", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gio" "DBusInterface")+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_object_get_interfaces" g_dbus_object_get_interfaces :: +    Ptr DBusObject ->                       -- _obj : TInterface "Gio" "DBusObject"+    IO (Ptr (GList (Ptr DBusInterface)))+++dBusObjectGetInterfaces ::+    (MonadIO m, DBusObjectK a) =>+    a ->                                    -- _obj+    m [DBusInterface]+dBusObjectGetInterfaces _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_object_get_interfaces _obj'+    checkUnexpectedReturnNULL "g_dbus_object_get_interfaces" result+    result' <- unpackGList result+    result'' <- mapM (wrapObject DBusInterface) result'+    g_list_free result+    touchManagedPtr _obj+    return result''++-- method DBusObject::get_object_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObject", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObject", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_object_get_object_path" g_dbus_object_get_object_path :: +    Ptr DBusObject ->                       -- _obj : TInterface "Gio" "DBusObject"+    IO CString+++dBusObjectGetObjectPath ::+    (MonadIO m, DBusObjectK a) =>+    a ->                                    -- _obj+    m T.Text+dBusObjectGetObjectPath _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_object_get_object_path _obj'+    checkUnexpectedReturnNULL "g_dbus_object_get_object_path" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++
+ GI/Gio/Interfaces/DBusObject.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gio.Interfaces.DBusObject where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype DBusObject = DBusObject (ForeignPtr DBusObject)+data DBusObjectInterfaceAddedSignalInfo+data DBusObjectInterfaceRemovedSignalInfo+instance GObject DBusObject where+class GObject o => DBusObjectK o+instance (GObject o, IsDescendantOf DBusObject o) => DBusObjectK o
+ GI/Gio/Interfaces/DBusObjectManager.hs view
@@ -0,0 +1,444 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Interfaces.DBusObjectManager+    ( ++-- * Exported types+    DBusObjectManager(..)                   ,+    noDBusObjectManager                     ,+    DBusObjectManagerK                      ,+    toDBusObjectManager                     ,+++ -- * Methods+-- ** dBusObjectManagerGetInterface+    dBusObjectManagerGetInterface           ,+++-- ** dBusObjectManagerGetObject+    dBusObjectManagerGetObject              ,+++-- ** dBusObjectManagerGetObjectPath+    dBusObjectManagerGetObjectPath          ,+++-- ** dBusObjectManagerGetObjects+    dBusObjectManagerGetObjects             ,+++++ -- * Signals+-- ** InterfaceAdded+    DBusObjectManagerInterfaceAddedCallback ,+    DBusObjectManagerInterfaceAddedCallbackC,+    DBusObjectManagerInterfaceAddedSignalInfo,+    afterDBusObjectManagerInterfaceAdded    ,+    dBusObjectManagerInterfaceAddedCallbackWrapper,+    dBusObjectManagerInterfaceAddedClosure  ,+    mkDBusObjectManagerInterfaceAddedCallback,+    noDBusObjectManagerInterfaceAddedCallback,+    onDBusObjectManagerInterfaceAdded       ,+++-- ** InterfaceRemoved+    DBusObjectManagerInterfaceRemovedCallback,+    DBusObjectManagerInterfaceRemovedCallbackC,+    DBusObjectManagerInterfaceRemovedSignalInfo,+    afterDBusObjectManagerInterfaceRemoved  ,+    dBusObjectManagerInterfaceRemovedCallbackWrapper,+    dBusObjectManagerInterfaceRemovedClosure,+    mkDBusObjectManagerInterfaceRemovedCallback,+    noDBusObjectManagerInterfaceRemovedCallback,+    onDBusObjectManagerInterfaceRemoved     ,+++-- ** ObjectAdded+    DBusObjectManagerObjectAddedCallback    ,+    DBusObjectManagerObjectAddedCallbackC   ,+    DBusObjectManagerObjectAddedSignalInfo  ,+    afterDBusObjectManagerObjectAdded       ,+    dBusObjectManagerObjectAddedCallbackWrapper,+    dBusObjectManagerObjectAddedClosure     ,+    mkDBusObjectManagerObjectAddedCallback  ,+    noDBusObjectManagerObjectAddedCallback  ,+    onDBusObjectManagerObjectAdded          ,+++-- ** ObjectRemoved+    DBusObjectManagerObjectRemovedCallback  ,+    DBusObjectManagerObjectRemovedCallbackC ,+    DBusObjectManagerObjectRemovedSignalInfo,+    afterDBusObjectManagerObjectRemoved     ,+    dBusObjectManagerObjectRemovedCallbackWrapper,+    dBusObjectManagerObjectRemovedClosure   ,+    mkDBusObjectManagerObjectRemovedCallback,+    noDBusObjectManagerObjectRemovedCallback,+    onDBusObjectManagerObjectRemoved        ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++-- interface DBusObjectManager ++newtype DBusObjectManager = DBusObjectManager (ForeignPtr DBusObjectManager)+noDBusObjectManager :: Maybe DBusObjectManager+noDBusObjectManager = Nothing++-- signal DBusObjectManager::interface-added+type DBusObjectManagerInterfaceAddedCallback =+    DBusObject ->+    DBusInterface ->+    IO ()++noDBusObjectManagerInterfaceAddedCallback :: Maybe DBusObjectManagerInterfaceAddedCallback+noDBusObjectManagerInterfaceAddedCallback = Nothing++type DBusObjectManagerInterfaceAddedCallbackC =+    Ptr () ->                               -- object+    Ptr DBusObject ->+    Ptr DBusInterface ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkDBusObjectManagerInterfaceAddedCallback :: DBusObjectManagerInterfaceAddedCallbackC -> IO (FunPtr DBusObjectManagerInterfaceAddedCallbackC)++dBusObjectManagerInterfaceAddedClosure :: DBusObjectManagerInterfaceAddedCallback -> IO Closure+dBusObjectManagerInterfaceAddedClosure cb = newCClosure =<< mkDBusObjectManagerInterfaceAddedCallback wrapped+    where wrapped = dBusObjectManagerInterfaceAddedCallbackWrapper cb++dBusObjectManagerInterfaceAddedCallbackWrapper ::+    DBusObjectManagerInterfaceAddedCallback ->+    Ptr () ->+    Ptr DBusObject ->+    Ptr DBusInterface ->+    Ptr () ->+    IO ()+dBusObjectManagerInterfaceAddedCallbackWrapper _cb _ object interface _ = do+    object' <- (newObject DBusObject) object+    interface' <- (newObject DBusInterface) interface+    _cb  object' interface'++onDBusObjectManagerInterfaceAdded :: (GObject a, MonadIO m) => a -> DBusObjectManagerInterfaceAddedCallback -> m SignalHandlerId+onDBusObjectManagerInterfaceAdded obj cb = liftIO $ connectDBusObjectManagerInterfaceAdded obj cb SignalConnectBefore+afterDBusObjectManagerInterfaceAdded :: (GObject a, MonadIO m) => a -> DBusObjectManagerInterfaceAddedCallback -> m SignalHandlerId+afterDBusObjectManagerInterfaceAdded obj cb = connectDBusObjectManagerInterfaceAdded obj cb SignalConnectAfter++connectDBusObjectManagerInterfaceAdded :: (GObject a, MonadIO m) =>+                                          a -> DBusObjectManagerInterfaceAddedCallback -> SignalConnectMode -> m SignalHandlerId+connectDBusObjectManagerInterfaceAdded obj cb after = liftIO $ do+    cb' <- mkDBusObjectManagerInterfaceAddedCallback (dBusObjectManagerInterfaceAddedCallbackWrapper cb)+    connectSignalFunPtr obj "interface-added" cb' after++-- signal DBusObjectManager::interface-removed+type DBusObjectManagerInterfaceRemovedCallback =+    DBusObject ->+    DBusInterface ->+    IO ()++noDBusObjectManagerInterfaceRemovedCallback :: Maybe DBusObjectManagerInterfaceRemovedCallback+noDBusObjectManagerInterfaceRemovedCallback = Nothing++type DBusObjectManagerInterfaceRemovedCallbackC =+    Ptr () ->                               -- object+    Ptr DBusObject ->+    Ptr DBusInterface ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkDBusObjectManagerInterfaceRemovedCallback :: DBusObjectManagerInterfaceRemovedCallbackC -> IO (FunPtr DBusObjectManagerInterfaceRemovedCallbackC)++dBusObjectManagerInterfaceRemovedClosure :: DBusObjectManagerInterfaceRemovedCallback -> IO Closure+dBusObjectManagerInterfaceRemovedClosure cb = newCClosure =<< mkDBusObjectManagerInterfaceRemovedCallback wrapped+    where wrapped = dBusObjectManagerInterfaceRemovedCallbackWrapper cb++dBusObjectManagerInterfaceRemovedCallbackWrapper ::+    DBusObjectManagerInterfaceRemovedCallback ->+    Ptr () ->+    Ptr DBusObject ->+    Ptr DBusInterface ->+    Ptr () ->+    IO ()+dBusObjectManagerInterfaceRemovedCallbackWrapper _cb _ object interface _ = do+    object' <- (newObject DBusObject) object+    interface' <- (newObject DBusInterface) interface+    _cb  object' interface'++onDBusObjectManagerInterfaceRemoved :: (GObject a, MonadIO m) => a -> DBusObjectManagerInterfaceRemovedCallback -> m SignalHandlerId+onDBusObjectManagerInterfaceRemoved obj cb = liftIO $ connectDBusObjectManagerInterfaceRemoved obj cb SignalConnectBefore+afterDBusObjectManagerInterfaceRemoved :: (GObject a, MonadIO m) => a -> DBusObjectManagerInterfaceRemovedCallback -> m SignalHandlerId+afterDBusObjectManagerInterfaceRemoved obj cb = connectDBusObjectManagerInterfaceRemoved obj cb SignalConnectAfter++connectDBusObjectManagerInterfaceRemoved :: (GObject a, MonadIO m) =>+                                            a -> DBusObjectManagerInterfaceRemovedCallback -> SignalConnectMode -> m SignalHandlerId+connectDBusObjectManagerInterfaceRemoved obj cb after = liftIO $ do+    cb' <- mkDBusObjectManagerInterfaceRemovedCallback (dBusObjectManagerInterfaceRemovedCallbackWrapper cb)+    connectSignalFunPtr obj "interface-removed" cb' after++-- signal DBusObjectManager::object-added+type DBusObjectManagerObjectAddedCallback =+    DBusObject ->+    IO ()++noDBusObjectManagerObjectAddedCallback :: Maybe DBusObjectManagerObjectAddedCallback+noDBusObjectManagerObjectAddedCallback = Nothing++type DBusObjectManagerObjectAddedCallbackC =+    Ptr () ->                               -- object+    Ptr DBusObject ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkDBusObjectManagerObjectAddedCallback :: DBusObjectManagerObjectAddedCallbackC -> IO (FunPtr DBusObjectManagerObjectAddedCallbackC)++dBusObjectManagerObjectAddedClosure :: DBusObjectManagerObjectAddedCallback -> IO Closure+dBusObjectManagerObjectAddedClosure cb = newCClosure =<< mkDBusObjectManagerObjectAddedCallback wrapped+    where wrapped = dBusObjectManagerObjectAddedCallbackWrapper cb++dBusObjectManagerObjectAddedCallbackWrapper ::+    DBusObjectManagerObjectAddedCallback ->+    Ptr () ->+    Ptr DBusObject ->+    Ptr () ->+    IO ()+dBusObjectManagerObjectAddedCallbackWrapper _cb _ object _ = do+    object' <- (newObject DBusObject) object+    _cb  object'++onDBusObjectManagerObjectAdded :: (GObject a, MonadIO m) => a -> DBusObjectManagerObjectAddedCallback -> m SignalHandlerId+onDBusObjectManagerObjectAdded obj cb = liftIO $ connectDBusObjectManagerObjectAdded obj cb SignalConnectBefore+afterDBusObjectManagerObjectAdded :: (GObject a, MonadIO m) => a -> DBusObjectManagerObjectAddedCallback -> m SignalHandlerId+afterDBusObjectManagerObjectAdded obj cb = connectDBusObjectManagerObjectAdded obj cb SignalConnectAfter++connectDBusObjectManagerObjectAdded :: (GObject a, MonadIO m) =>+                                       a -> DBusObjectManagerObjectAddedCallback -> SignalConnectMode -> m SignalHandlerId+connectDBusObjectManagerObjectAdded obj cb after = liftIO $ do+    cb' <- mkDBusObjectManagerObjectAddedCallback (dBusObjectManagerObjectAddedCallbackWrapper cb)+    connectSignalFunPtr obj "object-added" cb' after++-- signal DBusObjectManager::object-removed+type DBusObjectManagerObjectRemovedCallback =+    DBusObject ->+    IO ()++noDBusObjectManagerObjectRemovedCallback :: Maybe DBusObjectManagerObjectRemovedCallback+noDBusObjectManagerObjectRemovedCallback = Nothing++type DBusObjectManagerObjectRemovedCallbackC =+    Ptr () ->                               -- object+    Ptr DBusObject ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkDBusObjectManagerObjectRemovedCallback :: DBusObjectManagerObjectRemovedCallbackC -> IO (FunPtr DBusObjectManagerObjectRemovedCallbackC)++dBusObjectManagerObjectRemovedClosure :: DBusObjectManagerObjectRemovedCallback -> IO Closure+dBusObjectManagerObjectRemovedClosure cb = newCClosure =<< mkDBusObjectManagerObjectRemovedCallback wrapped+    where wrapped = dBusObjectManagerObjectRemovedCallbackWrapper cb++dBusObjectManagerObjectRemovedCallbackWrapper ::+    DBusObjectManagerObjectRemovedCallback ->+    Ptr () ->+    Ptr DBusObject ->+    Ptr () ->+    IO ()+dBusObjectManagerObjectRemovedCallbackWrapper _cb _ object _ = do+    object' <- (newObject DBusObject) object+    _cb  object'++onDBusObjectManagerObjectRemoved :: (GObject a, MonadIO m) => a -> DBusObjectManagerObjectRemovedCallback -> m SignalHandlerId+onDBusObjectManagerObjectRemoved obj cb = liftIO $ connectDBusObjectManagerObjectRemoved obj cb SignalConnectBefore+afterDBusObjectManagerObjectRemoved :: (GObject a, MonadIO m) => a -> DBusObjectManagerObjectRemovedCallback -> m SignalHandlerId+afterDBusObjectManagerObjectRemoved obj cb = connectDBusObjectManagerObjectRemoved obj cb SignalConnectAfter++connectDBusObjectManagerObjectRemoved :: (GObject a, MonadIO m) =>+                                         a -> DBusObjectManagerObjectRemovedCallback -> SignalConnectMode -> m SignalHandlerId+connectDBusObjectManagerObjectRemoved obj cb after = liftIO $ do+    cb' <- mkDBusObjectManagerObjectRemovedCallback (dBusObjectManagerObjectRemovedCallbackWrapper cb)+    connectSignalFunPtr obj "object-removed" cb' after++type instance AttributeList DBusObjectManager = DBusObjectManagerAttributeList+type DBusObjectManagerAttributeList = ('[ ] :: [(Symbol, *)])++data DBusObjectManagerInterfaceAddedSignalInfo+instance SignalInfo DBusObjectManagerInterfaceAddedSignalInfo where+    type HaskellCallbackType DBusObjectManagerInterfaceAddedSignalInfo = DBusObjectManagerInterfaceAddedCallback+    connectSignal _ = connectDBusObjectManagerInterfaceAdded++data DBusObjectManagerInterfaceRemovedSignalInfo+instance SignalInfo DBusObjectManagerInterfaceRemovedSignalInfo where+    type HaskellCallbackType DBusObjectManagerInterfaceRemovedSignalInfo = DBusObjectManagerInterfaceRemovedCallback+    connectSignal _ = connectDBusObjectManagerInterfaceRemoved++data DBusObjectManagerObjectAddedSignalInfo+instance SignalInfo DBusObjectManagerObjectAddedSignalInfo where+    type HaskellCallbackType DBusObjectManagerObjectAddedSignalInfo = DBusObjectManagerObjectAddedCallback+    connectSignal _ = connectDBusObjectManagerObjectAdded++data DBusObjectManagerObjectRemovedSignalInfo+instance SignalInfo DBusObjectManagerObjectRemovedSignalInfo where+    type HaskellCallbackType DBusObjectManagerObjectRemovedSignalInfo = DBusObjectManagerObjectRemovedCallback+    connectSignal _ = connectDBusObjectManagerObjectRemoved++type instance SignalList DBusObjectManager = DBusObjectManagerSignalList+type DBusObjectManagerSignalList = ('[ '("interface-added", DBusObjectManagerInterfaceAddedSignalInfo), '("interface-removed", DBusObjectManagerInterfaceRemovedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("object-added", DBusObjectManagerObjectAddedSignalInfo), '("object-removed", DBusObjectManagerObjectRemovedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "g_dbus_object_manager_get_type"+    c_g_dbus_object_manager_get_type :: IO GType++type instance ParentTypes DBusObjectManager = DBusObjectManagerParentTypes+type DBusObjectManagerParentTypes = '[GObject.Object]++instance GObject DBusObjectManager where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_dbus_object_manager_get_type+    ++class GObject o => DBusObjectManagerK o+instance (GObject o, IsDescendantOf DBusObjectManager o) => DBusObjectManagerK o++toDBusObjectManager :: DBusObjectManagerK o => o -> IO DBusObjectManager+toDBusObjectManager = unsafeCastTo DBusObjectManager++-- method DBusObjectManager::get_interface+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectManager", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectManager", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusInterface"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_object_manager_get_interface" g_dbus_object_manager_get_interface :: +    Ptr DBusObjectManager ->                -- _obj : TInterface "Gio" "DBusObjectManager"+    CString ->                              -- object_path : TBasicType TUTF8+    CString ->                              -- interface_name : TBasicType TUTF8+    IO (Ptr DBusInterface)+++dBusObjectManagerGetInterface ::+    (MonadIO m, DBusObjectManagerK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- object_path+    T.Text ->                               -- interface_name+    m DBusInterface+dBusObjectManagerGetInterface _obj object_path interface_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    object_path' <- textToCString object_path+    interface_name' <- textToCString interface_name+    result <- g_dbus_object_manager_get_interface _obj' object_path' interface_name'+    checkUnexpectedReturnNULL "g_dbus_object_manager_get_interface" result+    result' <- (wrapObject DBusInterface) result+    touchManagedPtr _obj+    freeMem object_path'+    freeMem interface_name'+    return result'++-- method DBusObjectManager::get_object+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectManager", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectManager", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusObject"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_object_manager_get_object" g_dbus_object_manager_get_object :: +    Ptr DBusObjectManager ->                -- _obj : TInterface "Gio" "DBusObjectManager"+    CString ->                              -- object_path : TBasicType TUTF8+    IO (Ptr DBusObject)+++dBusObjectManagerGetObject ::+    (MonadIO m, DBusObjectManagerK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- object_path+    m DBusObject+dBusObjectManagerGetObject _obj object_path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    object_path' <- textToCString object_path+    result <- g_dbus_object_manager_get_object _obj' object_path'+    checkUnexpectedReturnNULL "g_dbus_object_manager_get_object" result+    result' <- (wrapObject DBusObject) result+    touchManagedPtr _obj+    freeMem object_path'+    return result'++-- method DBusObjectManager::get_object_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectManager", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectManager", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_object_manager_get_object_path" g_dbus_object_manager_get_object_path :: +    Ptr DBusObjectManager ->                -- _obj : TInterface "Gio" "DBusObjectManager"+    IO CString+++dBusObjectManagerGetObjectPath ::+    (MonadIO m, DBusObjectManagerK a) =>+    a ->                                    -- _obj+    m T.Text+dBusObjectManagerGetObjectPath _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_object_manager_get_object_path _obj'+    checkUnexpectedReturnNULL "g_dbus_object_manager_get_object_path" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method DBusObjectManager::get_objects+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectManager", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectManager", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gio" "DBusObject")+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_object_manager_get_objects" g_dbus_object_manager_get_objects :: +    Ptr DBusObjectManager ->                -- _obj : TInterface "Gio" "DBusObjectManager"+    IO (Ptr (GList (Ptr DBusObject)))+++dBusObjectManagerGetObjects ::+    (MonadIO m, DBusObjectManagerK a) =>+    a ->                                    -- _obj+    m [DBusObject]+dBusObjectManagerGetObjects _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_object_manager_get_objects _obj'+    checkUnexpectedReturnNULL "g_dbus_object_manager_get_objects" result+    result' <- unpackGList result+    result'' <- mapM (wrapObject DBusObject) result'+    g_list_free result+    touchManagedPtr _obj+    return result''++
+ GI/Gio/Interfaces/DBusObjectManager.hs-boot view
@@ -0,0 +1,17 @@+module GI.Gio.Interfaces.DBusObjectManager where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype DBusObjectManager = DBusObjectManager (ForeignPtr DBusObjectManager)+data DBusObjectManagerInterfaceAddedSignalInfo+data DBusObjectManagerInterfaceRemovedSignalInfo+data DBusObjectManagerObjectAddedSignalInfo+data DBusObjectManagerObjectRemovedSignalInfo+instance GObject DBusObjectManager where+class GObject o => DBusObjectManagerK o+instance (GObject o, IsDescendantOf DBusObjectManager o) => DBusObjectManagerK o
+ GI/Gio/Interfaces/DesktopAppInfoLookup.hs view
@@ -0,0 +1,97 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Interfaces.DesktopAppInfoLookup+    ( ++-- * Exported types+    DesktopAppInfoLookup(..)                ,+    noDesktopAppInfoLookup                  ,+    DesktopAppInfoLookupK                   ,+    toDesktopAppInfoLookup                  ,+++ -- * Methods+-- ** desktopAppInfoLookupGetDefaultForUriScheme+    desktopAppInfoLookupGetDefaultForUriScheme,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++-- interface DesktopAppInfoLookup ++newtype DesktopAppInfoLookup = DesktopAppInfoLookup (ForeignPtr DesktopAppInfoLookup)+noDesktopAppInfoLookup :: Maybe DesktopAppInfoLookup+noDesktopAppInfoLookup = Nothing++type instance AttributeList DesktopAppInfoLookup = DesktopAppInfoLookupAttributeList+type DesktopAppInfoLookupAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList DesktopAppInfoLookup = DesktopAppInfoLookupSignalList+type DesktopAppInfoLookupSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "g_desktop_app_info_lookup_get_type"+    c_g_desktop_app_info_lookup_get_type :: IO GType++type instance ParentTypes DesktopAppInfoLookup = DesktopAppInfoLookupParentTypes+type DesktopAppInfoLookupParentTypes = '[GObject.Object]++instance GObject DesktopAppInfoLookup where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_desktop_app_info_lookup_get_type+    ++class GObject o => DesktopAppInfoLookupK o+instance (GObject o, IsDescendantOf DesktopAppInfoLookup o) => DesktopAppInfoLookupK o++toDesktopAppInfoLookup :: DesktopAppInfoLookupK o => o -> IO DesktopAppInfoLookup+toDesktopAppInfoLookup = unsafeCastTo DesktopAppInfoLookup++-- method DesktopAppInfoLookup::get_default_for_uri_scheme+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DesktopAppInfoLookup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "uri_scheme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DesktopAppInfoLookup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "uri_scheme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "AppInfo"+-- throws : False+-- Skip return : False++foreign import ccall "g_desktop_app_info_lookup_get_default_for_uri_scheme" g_desktop_app_info_lookup_get_default_for_uri_scheme :: +    Ptr DesktopAppInfoLookup ->             -- _obj : TInterface "Gio" "DesktopAppInfoLookup"+    CString ->                              -- uri_scheme : TBasicType TUTF8+    IO (Ptr AppInfo)++{-# DEPRECATED desktopAppInfoLookupGetDefaultForUriScheme ["The #GDesktopAppInfoLookup interface is deprecated and unused by gio."]#-}+desktopAppInfoLookupGetDefaultForUriScheme ::+    (MonadIO m, DesktopAppInfoLookupK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- uri_scheme+    m AppInfo+desktopAppInfoLookupGetDefaultForUriScheme _obj uri_scheme = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    uri_scheme' <- textToCString uri_scheme+    result <- g_desktop_app_info_lookup_get_default_for_uri_scheme _obj' uri_scheme'+    checkUnexpectedReturnNULL "g_desktop_app_info_lookup_get_default_for_uri_scheme" result+    result' <- (wrapObject AppInfo) result+    touchManagedPtr _obj+    freeMem uri_scheme'+    return result'++
+ GI/Gio/Interfaces/DesktopAppInfoLookup.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Interfaces.DesktopAppInfoLookup where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype DesktopAppInfoLookup = DesktopAppInfoLookup (ForeignPtr DesktopAppInfoLookup)+instance GObject DesktopAppInfoLookup where+class GObject o => DesktopAppInfoLookupK o+instance (GObject o, IsDescendantOf DesktopAppInfoLookup o) => DesktopAppInfoLookupK o
+ GI/Gio/Interfaces/Drive.hs view
@@ -0,0 +1,1252 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Interfaces.Drive+    ( ++-- * Exported types+    Drive(..)                               ,+    noDrive                                 ,+    DriveK                                  ,+    toDrive                                 ,+++ -- * Methods+-- ** driveCanEject+    driveCanEject                           ,+++-- ** driveCanPollForMedia+    driveCanPollForMedia                    ,+++-- ** driveCanStart+    driveCanStart                           ,+++-- ** driveCanStartDegraded+    driveCanStartDegraded                   ,+++-- ** driveCanStop+    driveCanStop                            ,+++-- ** driveEject+    driveEject                              ,+++-- ** driveEjectFinish+    driveEjectFinish                        ,+++-- ** driveEjectWithOperation+    driveEjectWithOperation                 ,+++-- ** driveEjectWithOperationFinish+    driveEjectWithOperationFinish           ,+++-- ** driveEnumerateIdentifiers+    driveEnumerateIdentifiers               ,+++-- ** driveGetIcon+    driveGetIcon                            ,+++-- ** driveGetIdentifier+    driveGetIdentifier                      ,+++-- ** driveGetName+    driveGetName                            ,+++-- ** driveGetSortKey+    driveGetSortKey                         ,+++-- ** driveGetStartStopType+    driveGetStartStopType                   ,+++-- ** driveGetSymbolicIcon+    driveGetSymbolicIcon                    ,+++-- ** driveGetVolumes+    driveGetVolumes                         ,+++-- ** driveHasMedia+    driveHasMedia                           ,+++-- ** driveHasVolumes+    driveHasVolumes                         ,+++-- ** driveIsMediaCheckAutomatic+    driveIsMediaCheckAutomatic              ,+++-- ** driveIsMediaRemovable+    driveIsMediaRemovable                   ,+++-- ** drivePollForMedia+    drivePollForMedia                       ,+++-- ** drivePollForMediaFinish+    drivePollForMediaFinish                 ,+++-- ** driveStart+    driveStart                              ,+++-- ** driveStartFinish+    driveStartFinish                        ,+++-- ** driveStop+    driveStop                               ,+++-- ** driveStopFinish+    driveStopFinish                         ,+++++ -- * Signals+-- ** Changed+    DriveChangedCallback                    ,+    DriveChangedCallbackC                   ,+    DriveChangedSignalInfo                  ,+    afterDriveChanged                       ,+    driveChangedCallbackWrapper             ,+    driveChangedClosure                     ,+    mkDriveChangedCallback                  ,+    noDriveChangedCallback                  ,+    onDriveChanged                          ,+++-- ** Disconnected+    DriveDisconnectedCallback               ,+    DriveDisconnectedCallbackC              ,+    DriveDisconnectedSignalInfo             ,+    afterDriveDisconnected                  ,+    driveDisconnectedCallbackWrapper        ,+    driveDisconnectedClosure                ,+    mkDriveDisconnectedCallback             ,+    noDriveDisconnectedCallback             ,+    onDriveDisconnected                     ,+++-- ** EjectButton+    DriveEjectButtonCallback                ,+    DriveEjectButtonCallbackC               ,+    DriveEjectButtonSignalInfo              ,+    afterDriveEjectButton                   ,+    driveEjectButtonCallbackWrapper         ,+    driveEjectButtonClosure                 ,+    mkDriveEjectButtonCallback              ,+    noDriveEjectButtonCallback              ,+    onDriveEjectButton                      ,+++-- ** StopButton+    DriveStopButtonCallback                 ,+    DriveStopButtonCallbackC                ,+    DriveStopButtonSignalInfo               ,+    afterDriveStopButton                    ,+    driveStopButtonCallbackWrapper          ,+    driveStopButtonClosure                  ,+    mkDriveStopButtonCallback               ,+    noDriveStopButtonCallback               ,+    onDriveStopButton                       ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++-- interface Drive ++newtype Drive = Drive (ForeignPtr Drive)+noDrive :: Maybe Drive+noDrive = Nothing++-- signal Drive::changed+type DriveChangedCallback =+    IO ()++noDriveChangedCallback :: Maybe DriveChangedCallback+noDriveChangedCallback = Nothing++type DriveChangedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkDriveChangedCallback :: DriveChangedCallbackC -> IO (FunPtr DriveChangedCallbackC)++driveChangedClosure :: DriveChangedCallback -> IO Closure+driveChangedClosure cb = newCClosure =<< mkDriveChangedCallback wrapped+    where wrapped = driveChangedCallbackWrapper cb++driveChangedCallbackWrapper ::+    DriveChangedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+driveChangedCallbackWrapper _cb _ _ = do+    _cb ++onDriveChanged :: (GObject a, MonadIO m) => a -> DriveChangedCallback -> m SignalHandlerId+onDriveChanged obj cb = liftIO $ connectDriveChanged obj cb SignalConnectBefore+afterDriveChanged :: (GObject a, MonadIO m) => a -> DriveChangedCallback -> m SignalHandlerId+afterDriveChanged obj cb = connectDriveChanged obj cb SignalConnectAfter++connectDriveChanged :: (GObject a, MonadIO m) =>+                       a -> DriveChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectDriveChanged obj cb after = liftIO $ do+    cb' <- mkDriveChangedCallback (driveChangedCallbackWrapper cb)+    connectSignalFunPtr obj "changed" cb' after++-- signal Drive::disconnected+type DriveDisconnectedCallback =+    IO ()++noDriveDisconnectedCallback :: Maybe DriveDisconnectedCallback+noDriveDisconnectedCallback = Nothing++type DriveDisconnectedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkDriveDisconnectedCallback :: DriveDisconnectedCallbackC -> IO (FunPtr DriveDisconnectedCallbackC)++driveDisconnectedClosure :: DriveDisconnectedCallback -> IO Closure+driveDisconnectedClosure cb = newCClosure =<< mkDriveDisconnectedCallback wrapped+    where wrapped = driveDisconnectedCallbackWrapper cb++driveDisconnectedCallbackWrapper ::+    DriveDisconnectedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+driveDisconnectedCallbackWrapper _cb _ _ = do+    _cb ++onDriveDisconnected :: (GObject a, MonadIO m) => a -> DriveDisconnectedCallback -> m SignalHandlerId+onDriveDisconnected obj cb = liftIO $ connectDriveDisconnected obj cb SignalConnectBefore+afterDriveDisconnected :: (GObject a, MonadIO m) => a -> DriveDisconnectedCallback -> m SignalHandlerId+afterDriveDisconnected obj cb = connectDriveDisconnected obj cb SignalConnectAfter++connectDriveDisconnected :: (GObject a, MonadIO m) =>+                            a -> DriveDisconnectedCallback -> SignalConnectMode -> m SignalHandlerId+connectDriveDisconnected obj cb after = liftIO $ do+    cb' <- mkDriveDisconnectedCallback (driveDisconnectedCallbackWrapper cb)+    connectSignalFunPtr obj "disconnected" cb' after++-- signal Drive::eject-button+type DriveEjectButtonCallback =+    IO ()++noDriveEjectButtonCallback :: Maybe DriveEjectButtonCallback+noDriveEjectButtonCallback = Nothing++type DriveEjectButtonCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkDriveEjectButtonCallback :: DriveEjectButtonCallbackC -> IO (FunPtr DriveEjectButtonCallbackC)++driveEjectButtonClosure :: DriveEjectButtonCallback -> IO Closure+driveEjectButtonClosure cb = newCClosure =<< mkDriveEjectButtonCallback wrapped+    where wrapped = driveEjectButtonCallbackWrapper cb++driveEjectButtonCallbackWrapper ::+    DriveEjectButtonCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+driveEjectButtonCallbackWrapper _cb _ _ = do+    _cb ++onDriveEjectButton :: (GObject a, MonadIO m) => a -> DriveEjectButtonCallback -> m SignalHandlerId+onDriveEjectButton obj cb = liftIO $ connectDriveEjectButton obj cb SignalConnectBefore+afterDriveEjectButton :: (GObject a, MonadIO m) => a -> DriveEjectButtonCallback -> m SignalHandlerId+afterDriveEjectButton obj cb = connectDriveEjectButton obj cb SignalConnectAfter++connectDriveEjectButton :: (GObject a, MonadIO m) =>+                           a -> DriveEjectButtonCallback -> SignalConnectMode -> m SignalHandlerId+connectDriveEjectButton obj cb after = liftIO $ do+    cb' <- mkDriveEjectButtonCallback (driveEjectButtonCallbackWrapper cb)+    connectSignalFunPtr obj "eject-button" cb' after++-- signal Drive::stop-button+type DriveStopButtonCallback =+    IO ()++noDriveStopButtonCallback :: Maybe DriveStopButtonCallback+noDriveStopButtonCallback = Nothing++type DriveStopButtonCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkDriveStopButtonCallback :: DriveStopButtonCallbackC -> IO (FunPtr DriveStopButtonCallbackC)++driveStopButtonClosure :: DriveStopButtonCallback -> IO Closure+driveStopButtonClosure cb = newCClosure =<< mkDriveStopButtonCallback wrapped+    where wrapped = driveStopButtonCallbackWrapper cb++driveStopButtonCallbackWrapper ::+    DriveStopButtonCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+driveStopButtonCallbackWrapper _cb _ _ = do+    _cb ++onDriveStopButton :: (GObject a, MonadIO m) => a -> DriveStopButtonCallback -> m SignalHandlerId+onDriveStopButton obj cb = liftIO $ connectDriveStopButton obj cb SignalConnectBefore+afterDriveStopButton :: (GObject a, MonadIO m) => a -> DriveStopButtonCallback -> m SignalHandlerId+afterDriveStopButton obj cb = connectDriveStopButton obj cb SignalConnectAfter++connectDriveStopButton :: (GObject a, MonadIO m) =>+                          a -> DriveStopButtonCallback -> SignalConnectMode -> m SignalHandlerId+connectDriveStopButton obj cb after = liftIO $ do+    cb' <- mkDriveStopButtonCallback (driveStopButtonCallbackWrapper cb)+    connectSignalFunPtr obj "stop-button" cb' after++type instance AttributeList Drive = DriveAttributeList+type DriveAttributeList = ('[ ] :: [(Symbol, *)])++data DriveChangedSignalInfo+instance SignalInfo DriveChangedSignalInfo where+    type HaskellCallbackType DriveChangedSignalInfo = DriveChangedCallback+    connectSignal _ = connectDriveChanged++data DriveDisconnectedSignalInfo+instance SignalInfo DriveDisconnectedSignalInfo where+    type HaskellCallbackType DriveDisconnectedSignalInfo = DriveDisconnectedCallback+    connectSignal _ = connectDriveDisconnected++data DriveEjectButtonSignalInfo+instance SignalInfo DriveEjectButtonSignalInfo where+    type HaskellCallbackType DriveEjectButtonSignalInfo = DriveEjectButtonCallback+    connectSignal _ = connectDriveEjectButton++data DriveStopButtonSignalInfo+instance SignalInfo DriveStopButtonSignalInfo where+    type HaskellCallbackType DriveStopButtonSignalInfo = DriveStopButtonCallback+    connectSignal _ = connectDriveStopButton++type instance SignalList Drive = DriveSignalList+type DriveSignalList = ('[ '("changed", DriveChangedSignalInfo), '("disconnected", DriveDisconnectedSignalInfo), '("eject-button", DriveEjectButtonSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("stop-button", DriveStopButtonSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "g_drive_get_type"+    c_g_drive_get_type :: IO GType++type instance ParentTypes Drive = DriveParentTypes+type DriveParentTypes = '[GObject.Object]++instance GObject Drive where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_drive_get_type+    ++class GObject o => DriveK o+instance (GObject o, IsDescendantOf Drive o) => DriveK o++toDrive :: DriveK o => o -> IO Drive+toDrive = unsafeCastTo Drive++-- method Drive::can_eject+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_drive_can_eject" g_drive_can_eject :: +    Ptr Drive ->                            -- _obj : TInterface "Gio" "Drive"+    IO CInt+++driveCanEject ::+    (MonadIO m, DriveK a) =>+    a ->                                    -- _obj+    m Bool+driveCanEject _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_drive_can_eject _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Drive::can_poll_for_media+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_drive_can_poll_for_media" g_drive_can_poll_for_media :: +    Ptr Drive ->                            -- _obj : TInterface "Gio" "Drive"+    IO CInt+++driveCanPollForMedia ::+    (MonadIO m, DriveK a) =>+    a ->                                    -- _obj+    m Bool+driveCanPollForMedia _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_drive_can_poll_for_media _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Drive::can_start+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_drive_can_start" g_drive_can_start :: +    Ptr Drive ->                            -- _obj : TInterface "Gio" "Drive"+    IO CInt+++driveCanStart ::+    (MonadIO m, DriveK a) =>+    a ->                                    -- _obj+    m Bool+driveCanStart _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_drive_can_start _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Drive::can_start_degraded+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_drive_can_start_degraded" g_drive_can_start_degraded :: +    Ptr Drive ->                            -- _obj : TInterface "Gio" "Drive"+    IO CInt+++driveCanStartDegraded ::+    (MonadIO m, DriveK a) =>+    a ->                                    -- _obj+    m Bool+driveCanStartDegraded _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_drive_can_start_degraded _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Drive::can_stop+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_drive_can_stop" g_drive_can_stop :: +    Ptr Drive ->                            -- _obj : TInterface "Gio" "Drive"+    IO CInt+++driveCanStop ::+    (MonadIO m, DriveK a) =>+    a ->                                    -- _obj+    m Bool+driveCanStop _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_drive_can_stop _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Drive::eject+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountUnmountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountUnmountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_drive_eject" g_drive_eject :: +    Ptr Drive ->                            -- _obj : TInterface "Gio" "Drive"+    CUInt ->                                -- flags : TInterface "Gio" "MountUnmountFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()++{-# DEPRECATED driveEject ["(Since version 2.22)","Use g_drive_eject_with_operation() instead."]#-}+driveEject ::+    (MonadIO m, DriveK a, CancellableK b) =>+    a ->                                    -- _obj+    [MountUnmountFlags] ->                  -- flags+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+driveEject _obj flags cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_drive_eject _obj' flags' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method Drive::eject_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_drive_eject_finish" g_drive_eject_finish :: +    Ptr Drive ->                            -- _obj : TInterface "Gio" "Drive"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt++{-# DEPRECATED driveEjectFinish ["(Since version 2.22)","Use g_drive_eject_with_operation_finish() instead."]#-}+driveEjectFinish ::+    (MonadIO m, DriveK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+driveEjectFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_drive_eject_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++-- method Drive::eject_with_operation+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountUnmountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mount_operation", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountUnmountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mount_operation", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_drive_eject_with_operation" g_drive_eject_with_operation :: +    Ptr Drive ->                            -- _obj : TInterface "Gio" "Drive"+    CUInt ->                                -- flags : TInterface "Gio" "MountUnmountFlags"+    Ptr MountOperation ->                   -- mount_operation : TInterface "Gio" "MountOperation"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++driveEjectWithOperation ::+    (MonadIO m, DriveK a, MountOperationK b, CancellableK c) =>+    a ->                                    -- _obj+    [MountUnmountFlags] ->                  -- flags+    Maybe (b) ->                            -- mount_operation+    Maybe (c) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+driveEjectWithOperation _obj flags mount_operation cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    maybeMount_operation <- case mount_operation of+        Nothing -> return nullPtr+        Just jMount_operation -> do+            let jMount_operation' = unsafeManagedPtrCastPtr jMount_operation+            return jMount_operation'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_drive_eject_with_operation _obj' flags' maybeMount_operation maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust mount_operation touchManagedPtr+    whenJust cancellable touchManagedPtr+    return ()++-- method Drive::eject_with_operation_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_drive_eject_with_operation_finish" g_drive_eject_with_operation_finish :: +    Ptr Drive ->                            -- _obj : TInterface "Gio" "Drive"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++driveEjectWithOperationFinish ::+    (MonadIO m, DriveK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+driveEjectWithOperationFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_drive_eject_with_operation_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++-- method Drive::enumerate_identifiers+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_drive_enumerate_identifiers" g_drive_enumerate_identifiers :: +    Ptr Drive ->                            -- _obj : TInterface "Gio" "Drive"+    IO (Ptr CString)+++driveEnumerateIdentifiers ::+    (MonadIO m, DriveK a) =>+    a ->                                    -- _obj+    m [T.Text]+driveEnumerateIdentifiers _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_drive_enumerate_identifiers _obj'+    checkUnexpectedReturnNULL "g_drive_enumerate_identifiers" result+    result' <- unpackZeroTerminatedUTF8CArray result+    mapZeroTerminatedCArray freeMem result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method Drive::get_icon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Icon"+-- throws : False+-- Skip return : False++foreign import ccall "g_drive_get_icon" g_drive_get_icon :: +    Ptr Drive ->                            -- _obj : TInterface "Gio" "Drive"+    IO (Ptr Icon)+++driveGetIcon ::+    (MonadIO m, DriveK a) =>+    a ->                                    -- _obj+    m Icon+driveGetIcon _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_drive_get_icon _obj'+    checkUnexpectedReturnNULL "g_drive_get_icon" result+    result' <- (wrapObject Icon) result+    touchManagedPtr _obj+    return result'++-- method Drive::get_identifier+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "kind", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "kind", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_drive_get_identifier" g_drive_get_identifier :: +    Ptr Drive ->                            -- _obj : TInterface "Gio" "Drive"+    CString ->                              -- kind : TBasicType TUTF8+    IO CString+++driveGetIdentifier ::+    (MonadIO m, DriveK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- kind+    m T.Text+driveGetIdentifier _obj kind = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    kind' <- textToCString kind+    result <- g_drive_get_identifier _obj' kind'+    checkUnexpectedReturnNULL "g_drive_get_identifier" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    freeMem kind'+    return result'++-- method Drive::get_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_drive_get_name" g_drive_get_name :: +    Ptr Drive ->                            -- _obj : TInterface "Gio" "Drive"+    IO CString+++driveGetName ::+    (MonadIO m, DriveK a) =>+    a ->                                    -- _obj+    m T.Text+driveGetName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_drive_get_name _obj'+    checkUnexpectedReturnNULL "g_drive_get_name" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method Drive::get_sort_key+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_drive_get_sort_key" g_drive_get_sort_key :: +    Ptr Drive ->                            -- _obj : TInterface "Gio" "Drive"+    IO CString+++driveGetSortKey ::+    (MonadIO m, DriveK a) =>+    a ->                                    -- _obj+    m T.Text+driveGetSortKey _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_drive_get_sort_key _obj'+    checkUnexpectedReturnNULL "g_drive_get_sort_key" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Drive::get_start_stop_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DriveStartStopType"+-- throws : False+-- Skip return : False++foreign import ccall "g_drive_get_start_stop_type" g_drive_get_start_stop_type :: +    Ptr Drive ->                            -- _obj : TInterface "Gio" "Drive"+    IO CUInt+++driveGetStartStopType ::+    (MonadIO m, DriveK a) =>+    a ->                                    -- _obj+    m DriveStartStopType+driveGetStartStopType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_drive_get_start_stop_type _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method Drive::get_symbolic_icon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Icon"+-- throws : False+-- Skip return : False++foreign import ccall "g_drive_get_symbolic_icon" g_drive_get_symbolic_icon :: +    Ptr Drive ->                            -- _obj : TInterface "Gio" "Drive"+    IO (Ptr Icon)+++driveGetSymbolicIcon ::+    (MonadIO m, DriveK a) =>+    a ->                                    -- _obj+    m Icon+driveGetSymbolicIcon _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_drive_get_symbolic_icon _obj'+    checkUnexpectedReturnNULL "g_drive_get_symbolic_icon" result+    result' <- (wrapObject Icon) result+    touchManagedPtr _obj+    return result'++-- method Drive::get_volumes+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gio" "Volume")+-- throws : False+-- Skip return : False++foreign import ccall "g_drive_get_volumes" g_drive_get_volumes :: +    Ptr Drive ->                            -- _obj : TInterface "Gio" "Drive"+    IO (Ptr (GList (Ptr Volume)))+++driveGetVolumes ::+    (MonadIO m, DriveK a) =>+    a ->                                    -- _obj+    m [Volume]+driveGetVolumes _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_drive_get_volumes _obj'+    checkUnexpectedReturnNULL "g_drive_get_volumes" result+    result' <- unpackGList result+    result'' <- mapM (wrapObject Volume) result'+    g_list_free result+    touchManagedPtr _obj+    return result''++-- method Drive::has_media+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_drive_has_media" g_drive_has_media :: +    Ptr Drive ->                            -- _obj : TInterface "Gio" "Drive"+    IO CInt+++driveHasMedia ::+    (MonadIO m, DriveK a) =>+    a ->                                    -- _obj+    m Bool+driveHasMedia _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_drive_has_media _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Drive::has_volumes+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_drive_has_volumes" g_drive_has_volumes :: +    Ptr Drive ->                            -- _obj : TInterface "Gio" "Drive"+    IO CInt+++driveHasVolumes ::+    (MonadIO m, DriveK a) =>+    a ->                                    -- _obj+    m Bool+driveHasVolumes _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_drive_has_volumes _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Drive::is_media_check_automatic+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_drive_is_media_check_automatic" g_drive_is_media_check_automatic :: +    Ptr Drive ->                            -- _obj : TInterface "Gio" "Drive"+    IO CInt+++driveIsMediaCheckAutomatic ::+    (MonadIO m, DriveK a) =>+    a ->                                    -- _obj+    m Bool+driveIsMediaCheckAutomatic _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_drive_is_media_check_automatic _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Drive::is_media_removable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_drive_is_media_removable" g_drive_is_media_removable :: +    Ptr Drive ->                            -- _obj : TInterface "Gio" "Drive"+    IO CInt+++driveIsMediaRemovable ::+    (MonadIO m, DriveK a) =>+    a ->                                    -- _obj+    m Bool+driveIsMediaRemovable _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_drive_is_media_removable _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Drive::poll_for_media+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_drive_poll_for_media" g_drive_poll_for_media :: +    Ptr Drive ->                            -- _obj : TInterface "Gio" "Drive"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++drivePollForMedia ::+    (MonadIO m, DriveK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+drivePollForMedia _obj cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_drive_poll_for_media _obj' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method Drive::poll_for_media_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_drive_poll_for_media_finish" g_drive_poll_for_media_finish :: +    Ptr Drive ->                            -- _obj : TInterface "Gio" "Drive"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++drivePollForMediaFinish ::+    (MonadIO m, DriveK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+drivePollForMediaFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_drive_poll_for_media_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++-- method Drive::start+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DriveStartFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mount_operation", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DriveStartFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mount_operation", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_drive_start" g_drive_start :: +    Ptr Drive ->                            -- _obj : TInterface "Gio" "Drive"+    CUInt ->                                -- flags : TInterface "Gio" "DriveStartFlags"+    Ptr MountOperation ->                   -- mount_operation : TInterface "Gio" "MountOperation"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++driveStart ::+    (MonadIO m, DriveK a, MountOperationK b, CancellableK c) =>+    a ->                                    -- _obj+    [DriveStartFlags] ->                    -- flags+    Maybe (b) ->                            -- mount_operation+    Maybe (c) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+driveStart _obj flags mount_operation cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    maybeMount_operation <- case mount_operation of+        Nothing -> return nullPtr+        Just jMount_operation -> do+            let jMount_operation' = unsafeManagedPtrCastPtr jMount_operation+            return jMount_operation'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_drive_start _obj' flags' maybeMount_operation maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust mount_operation touchManagedPtr+    whenJust cancellable touchManagedPtr+    return ()++-- method Drive::start_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_drive_start_finish" g_drive_start_finish :: +    Ptr Drive ->                            -- _obj : TInterface "Gio" "Drive"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++driveStartFinish ::+    (MonadIO m, DriveK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+driveStartFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_drive_start_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++-- method Drive::stop+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountUnmountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mount_operation", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountUnmountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mount_operation", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_drive_stop" g_drive_stop :: +    Ptr Drive ->                            -- _obj : TInterface "Gio" "Drive"+    CUInt ->                                -- flags : TInterface "Gio" "MountUnmountFlags"+    Ptr MountOperation ->                   -- mount_operation : TInterface "Gio" "MountOperation"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++driveStop ::+    (MonadIO m, DriveK a, MountOperationK b, CancellableK c) =>+    a ->                                    -- _obj+    [MountUnmountFlags] ->                  -- flags+    Maybe (b) ->                            -- mount_operation+    Maybe (c) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+driveStop _obj flags mount_operation cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    maybeMount_operation <- case mount_operation of+        Nothing -> return nullPtr+        Just jMount_operation -> do+            let jMount_operation' = unsafeManagedPtrCastPtr jMount_operation+            return jMount_operation'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_drive_stop _obj' flags' maybeMount_operation maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust mount_operation touchManagedPtr+    whenJust cancellable touchManagedPtr+    return ()++-- method Drive::stop_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Drive", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_drive_stop_finish" g_drive_stop_finish :: +    Ptr Drive ->                            -- _obj : TInterface "Gio" "Drive"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++driveStopFinish ::+    (MonadIO m, DriveK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+driveStopFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_drive_stop_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++
+ GI/Gio/Interfaces/Drive.hs-boot view
@@ -0,0 +1,17 @@+module GI.Gio.Interfaces.Drive where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Drive = Drive (ForeignPtr Drive)+data DriveChangedSignalInfo+data DriveDisconnectedSignalInfo+data DriveEjectButtonSignalInfo+data DriveStopButtonSignalInfo+instance GObject Drive where+class GObject o => DriveK o+instance (GObject o, IsDescendantOf Drive o) => DriveK o
+ GI/Gio/Interfaces/File.hs view
@@ -0,0 +1,5197 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Interfaces.File+    ( ++-- * Exported types+    File(..)                                ,+    noFile                                  ,+    FileK                                   ,+    toFile                                  ,+++ -- * Methods+-- ** fileAppendTo+    fileAppendTo                            ,+++-- ** fileAppendToAsync+    fileAppendToAsync                       ,+++-- ** fileAppendToFinish+    fileAppendToFinish                      ,+++-- ** fileCopy+    fileCopy                                ,+++-- ** fileCopyAttributes+    fileCopyAttributes                      ,+++-- ** fileCopyFinish+    fileCopyFinish                          ,+++-- ** fileCreate+    fileCreate                              ,+++-- ** fileCreateAsync+    fileCreateAsync                         ,+++-- ** fileCreateFinish+    fileCreateFinish                        ,+++-- ** fileCreateReadwrite+    fileCreateReadwrite                     ,+++-- ** fileCreateReadwriteAsync+    fileCreateReadwriteAsync                ,+++-- ** fileCreateReadwriteFinish+    fileCreateReadwriteFinish               ,+++-- ** fileDelete+    fileDelete                              ,+++-- ** fileDeleteAsync+    fileDeleteAsync                         ,+++-- ** fileDeleteFinish+    fileDeleteFinish                        ,+++-- ** fileDup+    fileDup                                 ,+++-- ** fileEjectMountable+    fileEjectMountable                      ,+++-- ** fileEjectMountableFinish+    fileEjectMountableFinish                ,+++-- ** fileEjectMountableWithOperation+    fileEjectMountableWithOperation         ,+++-- ** fileEjectMountableWithOperationFinish+    fileEjectMountableWithOperationFinish   ,+++-- ** fileEnumerateChildren+    fileEnumerateChildren                   ,+++-- ** fileEnumerateChildrenAsync+    fileEnumerateChildrenAsync              ,+++-- ** fileEnumerateChildrenFinish+    fileEnumerateChildrenFinish             ,+++-- ** fileEqual+    fileEqual                               ,+++-- ** fileFindEnclosingMount+    fileFindEnclosingMount                  ,+++-- ** fileFindEnclosingMountAsync+    fileFindEnclosingMountAsync             ,+++-- ** fileFindEnclosingMountFinish+    fileFindEnclosingMountFinish            ,+++-- ** fileGetBasename+    fileGetBasename                         ,+++-- ** fileGetChild+    fileGetChild                            ,+++-- ** fileGetChildForDisplayName+    fileGetChildForDisplayName              ,+++-- ** fileGetParent+    fileGetParent                           ,+++-- ** fileGetParseName+    fileGetParseName                        ,+++-- ** fileGetPath+    fileGetPath                             ,+++-- ** fileGetRelativePath+    fileGetRelativePath                     ,+++-- ** fileGetUri+    fileGetUri                              ,+++-- ** fileGetUriScheme+    fileGetUriScheme                        ,+++-- ** fileHasParent+    fileHasParent                           ,+++-- ** fileHasPrefix+    fileHasPrefix                           ,+++-- ** fileHasUriScheme+    fileHasUriScheme                        ,+++-- ** fileHash+    fileHash                                ,+++-- ** fileIsNative+    fileIsNative                            ,+++-- ** fileLoadContents+    fileLoadContents                        ,+++-- ** fileLoadContentsAsync+    fileLoadContentsAsync                   ,+++-- ** fileLoadContentsFinish+    fileLoadContentsFinish                  ,+++-- ** fileLoadPartialContentsFinish+    fileLoadPartialContentsFinish           ,+++-- ** fileMakeDirectory+    fileMakeDirectory                       ,+++-- ** fileMakeDirectoryAsync+    fileMakeDirectoryAsync                  ,+++-- ** fileMakeDirectoryFinish+    fileMakeDirectoryFinish                 ,+++-- ** fileMakeDirectoryWithParents+    fileMakeDirectoryWithParents            ,+++-- ** fileMakeSymbolicLink+    fileMakeSymbolicLink                    ,+++-- ** fileMeasureDiskUsageFinish+    fileMeasureDiskUsageFinish              ,+++-- ** fileMonitor+    fileMonitor                             ,+++-- ** fileMonitorDirectory+    fileMonitorDirectory                    ,+++-- ** fileMonitorFile+    fileMonitorFile                         ,+++-- ** fileMountEnclosingVolume+    fileMountEnclosingVolume                ,+++-- ** fileMountEnclosingVolumeFinish+    fileMountEnclosingVolumeFinish          ,+++-- ** fileMountMountable+    fileMountMountable                      ,+++-- ** fileMountMountableFinish+    fileMountMountableFinish                ,+++-- ** fileMove+    fileMove                                ,+++-- ** fileOpenReadwrite+    fileOpenReadwrite                       ,+++-- ** fileOpenReadwriteAsync+    fileOpenReadwriteAsync                  ,+++-- ** fileOpenReadwriteFinish+    fileOpenReadwriteFinish                 ,+++-- ** filePollMountable+    filePollMountable                       ,+++-- ** filePollMountableFinish+    filePollMountableFinish                 ,+++-- ** fileQueryDefaultHandler+    fileQueryDefaultHandler                 ,+++-- ** fileQueryExists+    fileQueryExists                         ,+++-- ** fileQueryFileType+    fileQueryFileType                       ,+++-- ** fileQueryFilesystemInfo+    fileQueryFilesystemInfo                 ,+++-- ** fileQueryFilesystemInfoAsync+    fileQueryFilesystemInfoAsync            ,+++-- ** fileQueryFilesystemInfoFinish+    fileQueryFilesystemInfoFinish           ,+++-- ** fileQueryInfo+    fileQueryInfo                           ,+++-- ** fileQueryInfoAsync+    fileQueryInfoAsync                      ,+++-- ** fileQueryInfoFinish+    fileQueryInfoFinish                     ,+++-- ** fileQuerySettableAttributes+    fileQuerySettableAttributes             ,+++-- ** fileQueryWritableNamespaces+    fileQueryWritableNamespaces             ,+++-- ** fileRead+    fileRead                                ,+++-- ** fileReadAsync+    fileReadAsync                           ,+++-- ** fileReadFinish+    fileReadFinish                          ,+++-- ** fileReplace+    fileReplace                             ,+++-- ** fileReplaceAsync+    fileReplaceAsync                        ,+++-- ** fileReplaceContents+    fileReplaceContents                     ,+++-- ** fileReplaceContentsAsync+    fileReplaceContentsAsync                ,+++-- ** fileReplaceContentsBytesAsync+    fileReplaceContentsBytesAsync           ,+++-- ** fileReplaceContentsFinish+    fileReplaceContentsFinish               ,+++-- ** fileReplaceFinish+    fileReplaceFinish                       ,+++-- ** fileReplaceReadwrite+    fileReplaceReadwrite                    ,+++-- ** fileReplaceReadwriteAsync+    fileReplaceReadwriteAsync               ,+++-- ** fileReplaceReadwriteFinish+    fileReplaceReadwriteFinish              ,+++-- ** fileResolveRelativePath+    fileResolveRelativePath                 ,+++-- ** fileSetAttribute+    fileSetAttribute                        ,+++-- ** fileSetAttributeByteString+    fileSetAttributeByteString              ,+++-- ** fileSetAttributeInt32+    fileSetAttributeInt32                   ,+++-- ** fileSetAttributeInt64+    fileSetAttributeInt64                   ,+++-- ** fileSetAttributeString+    fileSetAttributeString                  ,+++-- ** fileSetAttributeUint32+    fileSetAttributeUint32                  ,+++-- ** fileSetAttributeUint64+    fileSetAttributeUint64                  ,+++-- ** fileSetAttributesAsync+    fileSetAttributesAsync                  ,+++-- ** fileSetAttributesFinish+    fileSetAttributesFinish                 ,+++-- ** fileSetAttributesFromInfo+    fileSetAttributesFromInfo               ,+++-- ** fileSetDisplayName+    fileSetDisplayName                      ,+++-- ** fileSetDisplayNameAsync+    fileSetDisplayNameAsync                 ,+++-- ** fileSetDisplayNameFinish+    fileSetDisplayNameFinish                ,+++-- ** fileStartMountable+    fileStartMountable                      ,+++-- ** fileStartMountableFinish+    fileStartMountableFinish                ,+++-- ** fileStopMountable+    fileStopMountable                       ,+++-- ** fileStopMountableFinish+    fileStopMountableFinish                 ,+++-- ** fileSupportsThreadContexts+    fileSupportsThreadContexts              ,+++-- ** fileTrash+    fileTrash                               ,+++-- ** fileTrashAsync+    fileTrashAsync                          ,+++-- ** fileTrashFinish+    fileTrashFinish                         ,+++-- ** fileUnmountMountable+    fileUnmountMountable                    ,+++-- ** fileUnmountMountableFinish+    fileUnmountMountableFinish              ,+++-- ** fileUnmountMountableWithOperation+    fileUnmountMountableWithOperation       ,+++-- ** fileUnmountMountableWithOperationFinish+    fileUnmountMountableWithOperationFinish ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++-- interface File ++newtype File = File (ForeignPtr File)+noFile :: Maybe File+noFile = Nothing++type instance AttributeList File = FileAttributeList+type FileAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList File = FileSignalList+type FileSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "g_file_get_type"+    c_g_file_get_type :: IO GType++type instance ParentTypes File = FileParentTypes+type FileParentTypes = '[GObject.Object]++instance GObject File where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_file_get_type+    ++class GObject o => FileK o+instance (GObject o, IsDescendantOf File o) => FileK o++toFile :: FileK o => o -> IO File+toFile = unsafeCastTo File++-- method File::append_to+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileCreateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileCreateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileOutputStream"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_append_to" g_file_append_to :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CUInt ->                                -- flags : TInterface "Gio" "FileCreateFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr FileOutputStream)+++fileAppendTo ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    [FileCreateFlags] ->                    -- flags+    Maybe (b) ->                            -- cancellable+    m FileOutputStream+fileAppendTo _obj flags cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_file_append_to _obj' flags' maybeCancellable+        checkUnexpectedReturnNULL "g_file_append_to" result+        result' <- (wrapObject FileOutputStream) result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )++-- method File::append_to_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileCreateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileCreateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_append_to_async" g_file_append_to_async :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CUInt ->                                -- flags : TInterface "Gio" "FileCreateFlags"+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++fileAppendToAsync ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    [FileCreateFlags] ->                    -- flags+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+fileAppendToAsync _obj flags io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_file_append_to_async _obj' flags' io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method File::append_to_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileOutputStream"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_append_to_finish" g_file_append_to_finish :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr FileOutputStream)+++fileAppendToFinish ::+    (MonadIO m, FileK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- res+    m FileOutputStream+fileAppendToFinish _obj res = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let res' = unsafeManagedPtrCastPtr res+    onException (do+        result <- propagateGError $ g_file_append_to_finish _obj' res'+        checkUnexpectedReturnNULL "g_file_append_to_finish" result+        result' <- (wrapObject FileOutputStream) result+        touchManagedPtr _obj+        touchManagedPtr res+        return result'+     ) (do+        return ()+     )++-- method File::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "destination", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileCopyFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "progress_callback", argType = TInterface "Gio" "FileProgressCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeCall, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "progress_callback_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "destination", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileCopyFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "progress_callback", argType = TInterface "Gio" "FileProgressCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeCall, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_copy" g_file_copy :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr File ->                             -- destination : TInterface "Gio" "File"+    CUInt ->                                -- flags : TInterface "Gio" "FileCopyFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr FileProgressCallbackC ->         -- progress_callback : TInterface "Gio" "FileProgressCallback"+    Ptr () ->                               -- progress_callback_data : TBasicType TVoid+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileCopy ::+    (MonadIO m, FileK a, FileK b, CancellableK c) =>+    a ->                                    -- _obj+    b ->                                    -- destination+    [FileCopyFlags] ->                      -- flags+    Maybe (c) ->                            -- cancellable+    Maybe (FileProgressCallback) ->         -- progress_callback+    m ()+fileCopy _obj destination flags cancellable progress_callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let destination' = unsafeManagedPtrCastPtr destination+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    maybeProgress_callback <- case progress_callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jProgress_callback -> do+            jProgress_callback' <- mkFileProgressCallback (fileProgressCallbackWrapper Nothing jProgress_callback)+            return jProgress_callback'+    let progress_callback_data = nullPtr+    onException (do+        _ <- propagateGError $ g_file_copy _obj' destination' flags' maybeCancellable maybeProgress_callback progress_callback_data+        safeFreeFunPtr $ castFunPtrToPtr maybeProgress_callback+        touchManagedPtr _obj+        touchManagedPtr destination+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        safeFreeFunPtr $ castFunPtrToPtr maybeProgress_callback+        return ()+     )++-- method File::copy_attributes+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "destination", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileCopyFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "destination", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileCopyFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_copy_attributes" g_file_copy_attributes :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr File ->                             -- destination : TInterface "Gio" "File"+    CUInt ->                                -- flags : TInterface "Gio" "FileCopyFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileCopyAttributes ::+    (MonadIO m, FileK a, FileK b, CancellableK c) =>+    a ->                                    -- _obj+    b ->                                    -- destination+    [FileCopyFlags] ->                      -- flags+    Maybe (c) ->                            -- cancellable+    m ()+fileCopyAttributes _obj destination flags cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let destination' = unsafeManagedPtrCastPtr destination+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_file_copy_attributes _obj' destination' flags' maybeCancellable+        touchManagedPtr _obj+        touchManagedPtr destination+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method File::copy_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_copy_finish" g_file_copy_finish :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileCopyFinish ::+    (MonadIO m, FileK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- res+    m ()+fileCopyFinish _obj res = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let res' = unsafeManagedPtrCastPtr res+    onException (do+        _ <- propagateGError $ g_file_copy_finish _obj' res'+        touchManagedPtr _obj+        touchManagedPtr res+        return ()+     ) (do+        return ()+     )++-- method File::create+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileCreateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileCreateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileOutputStream"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_create" g_file_create :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CUInt ->                                -- flags : TInterface "Gio" "FileCreateFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr FileOutputStream)+++fileCreate ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    [FileCreateFlags] ->                    -- flags+    Maybe (b) ->                            -- cancellable+    m FileOutputStream+fileCreate _obj flags cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_file_create _obj' flags' maybeCancellable+        checkUnexpectedReturnNULL "g_file_create" result+        result' <- (wrapObject FileOutputStream) result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )++-- method File::create_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileCreateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileCreateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_create_async" g_file_create_async :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CUInt ->                                -- flags : TInterface "Gio" "FileCreateFlags"+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++fileCreateAsync ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    [FileCreateFlags] ->                    -- flags+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+fileCreateAsync _obj flags io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_file_create_async _obj' flags' io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method File::create_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileOutputStream"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_create_finish" g_file_create_finish :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr FileOutputStream)+++fileCreateFinish ::+    (MonadIO m, FileK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- res+    m FileOutputStream+fileCreateFinish _obj res = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let res' = unsafeManagedPtrCastPtr res+    onException (do+        result <- propagateGError $ g_file_create_finish _obj' res'+        checkUnexpectedReturnNULL "g_file_create_finish" result+        result' <- (wrapObject FileOutputStream) result+        touchManagedPtr _obj+        touchManagedPtr res+        return result'+     ) (do+        return ()+     )++-- method File::create_readwrite+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileCreateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileCreateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileIOStream"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_create_readwrite" g_file_create_readwrite :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CUInt ->                                -- flags : TInterface "Gio" "FileCreateFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr FileIOStream)+++fileCreateReadwrite ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    [FileCreateFlags] ->                    -- flags+    Maybe (b) ->                            -- cancellable+    m FileIOStream+fileCreateReadwrite _obj flags cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_file_create_readwrite _obj' flags' maybeCancellable+        checkUnexpectedReturnNULL "g_file_create_readwrite" result+        result' <- (wrapObject FileIOStream) result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )++-- method File::create_readwrite_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileCreateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileCreateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_create_readwrite_async" g_file_create_readwrite_async :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CUInt ->                                -- flags : TInterface "Gio" "FileCreateFlags"+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++fileCreateReadwriteAsync ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    [FileCreateFlags] ->                    -- flags+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+fileCreateReadwriteAsync _obj flags io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_file_create_readwrite_async _obj' flags' io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method File::create_readwrite_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileIOStream"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_create_readwrite_finish" g_file_create_readwrite_finish :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr FileIOStream)+++fileCreateReadwriteFinish ::+    (MonadIO m, FileK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- res+    m FileIOStream+fileCreateReadwriteFinish _obj res = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let res' = unsafeManagedPtrCastPtr res+    onException (do+        result <- propagateGError $ g_file_create_readwrite_finish _obj' res'+        checkUnexpectedReturnNULL "g_file_create_readwrite_finish" result+        result' <- (wrapObject FileIOStream) result+        touchManagedPtr _obj+        touchManagedPtr res+        return result'+     ) (do+        return ()+     )++-- method File::delete+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_delete" g_file_delete :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileDelete ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m ()+fileDelete _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_file_delete _obj' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method File::delete_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_delete_async" g_file_delete_async :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++fileDeleteAsync ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+fileDeleteAsync _obj io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_file_delete_async _obj' io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method File::delete_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_delete_finish" g_file_delete_finish :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileDeleteFinish ::+    (MonadIO m, FileK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+fileDeleteFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_file_delete_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++-- method File::dup+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "File"+-- throws : False+-- Skip return : False++foreign import ccall "g_file_dup" g_file_dup :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    IO (Ptr File)+++fileDup ::+    (MonadIO m, FileK a) =>+    a ->                                    -- _obj+    m File+fileDup _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_dup _obj'+    checkUnexpectedReturnNULL "g_file_dup" result+    result' <- (wrapObject File) result+    touchManagedPtr _obj+    return result'++-- method File::eject_mountable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountUnmountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountUnmountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_eject_mountable" g_file_eject_mountable :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CUInt ->                                -- flags : TInterface "Gio" "MountUnmountFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()++{-# DEPRECATED fileEjectMountable ["(Since version 2.22)","Use g_file_eject_mountable_with_operation() instead."]#-}+fileEjectMountable ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    [MountUnmountFlags] ->                  -- flags+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+fileEjectMountable _obj flags cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_file_eject_mountable _obj' flags' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method File::eject_mountable_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_eject_mountable_finish" g_file_eject_mountable_finish :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt++{-# DEPRECATED fileEjectMountableFinish ["(Since version 2.22)","Use g_file_eject_mountable_with_operation_finish()","    instead."]#-}+fileEjectMountableFinish ::+    (MonadIO m, FileK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+fileEjectMountableFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_file_eject_mountable_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++-- method File::eject_mountable_with_operation+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountUnmountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mount_operation", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountUnmountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mount_operation", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_eject_mountable_with_operation" g_file_eject_mountable_with_operation :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CUInt ->                                -- flags : TInterface "Gio" "MountUnmountFlags"+    Ptr MountOperation ->                   -- mount_operation : TInterface "Gio" "MountOperation"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++fileEjectMountableWithOperation ::+    (MonadIO m, FileK a, MountOperationK b, CancellableK c) =>+    a ->                                    -- _obj+    [MountUnmountFlags] ->                  -- flags+    Maybe (b) ->                            -- mount_operation+    Maybe (c) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+fileEjectMountableWithOperation _obj flags mount_operation cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    maybeMount_operation <- case mount_operation of+        Nothing -> return nullPtr+        Just jMount_operation -> do+            let jMount_operation' = unsafeManagedPtrCastPtr jMount_operation+            return jMount_operation'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_file_eject_mountable_with_operation _obj' flags' maybeMount_operation maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust mount_operation touchManagedPtr+    whenJust cancellable touchManagedPtr+    return ()++-- method File::eject_mountable_with_operation_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_eject_mountable_with_operation_finish" g_file_eject_mountable_with_operation_finish :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileEjectMountableWithOperationFinish ::+    (MonadIO m, FileK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+fileEjectMountableWithOperationFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_file_eject_mountable_with_operation_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++-- method File::enumerate_children+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attributes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileQueryInfoFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attributes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileQueryInfoFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileEnumerator"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_enumerate_children" g_file_enumerate_children :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CString ->                              -- attributes : TBasicType TUTF8+    CUInt ->                                -- flags : TInterface "Gio" "FileQueryInfoFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr FileEnumerator)+++fileEnumerateChildren ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- attributes+    [FileQueryInfoFlags] ->                 -- flags+    Maybe (b) ->                            -- cancellable+    m FileEnumerator+fileEnumerateChildren _obj attributes flags cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attributes' <- textToCString attributes+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_file_enumerate_children _obj' attributes' flags' maybeCancellable+        checkUnexpectedReturnNULL "g_file_enumerate_children" result+        result' <- (wrapObject FileEnumerator) result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem attributes'+        return result'+     ) (do+        freeMem attributes'+     )++-- method File::enumerate_children_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attributes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileQueryInfoFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attributes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileQueryInfoFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_enumerate_children_async" g_file_enumerate_children_async :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CString ->                              -- attributes : TBasicType TUTF8+    CUInt ->                                -- flags : TInterface "Gio" "FileQueryInfoFlags"+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++fileEnumerateChildrenAsync ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- attributes+    [FileQueryInfoFlags] ->                 -- flags+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+fileEnumerateChildrenAsync _obj attributes flags io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attributes' <- textToCString attributes+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_file_enumerate_children_async _obj' attributes' flags' io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    freeMem attributes'+    return ()++-- method File::enumerate_children_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileEnumerator"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_enumerate_children_finish" g_file_enumerate_children_finish :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr FileEnumerator)+++fileEnumerateChildrenFinish ::+    (MonadIO m, FileK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- res+    m FileEnumerator+fileEnumerateChildrenFinish _obj res = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let res' = unsafeManagedPtrCastPtr res+    onException (do+        result <- propagateGError $ g_file_enumerate_children_finish _obj' res'+        checkUnexpectedReturnNULL "g_file_enumerate_children_finish" result+        result' <- (wrapObject FileEnumerator) result+        touchManagedPtr _obj+        touchManagedPtr res+        return result'+     ) (do+        return ()+     )++-- method File::equal+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "file2", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "file2", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_file_equal" g_file_equal :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr File ->                             -- file2 : TInterface "Gio" "File"+    IO CInt+++fileEqual ::+    (MonadIO m, FileK a, FileK b) =>+    a ->                                    -- _obj+    b ->                                    -- file2+    m Bool+fileEqual _obj file2 = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let file2' = unsafeManagedPtrCastPtr file2+    result <- g_file_equal _obj' file2'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr file2+    return result'++-- method File::find_enclosing_mount+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Mount"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_find_enclosing_mount" g_file_find_enclosing_mount :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Mount)+++fileFindEnclosingMount ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m Mount+fileFindEnclosingMount _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_file_find_enclosing_mount _obj' maybeCancellable+        checkUnexpectedReturnNULL "g_file_find_enclosing_mount" result+        result' <- (wrapObject Mount) result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )++-- method File::find_enclosing_mount_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_find_enclosing_mount_async" g_file_find_enclosing_mount_async :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++fileFindEnclosingMountAsync ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+fileFindEnclosingMountAsync _obj io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_file_find_enclosing_mount_async _obj' io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method File::find_enclosing_mount_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Mount"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_find_enclosing_mount_finish" g_file_find_enclosing_mount_finish :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Mount)+++fileFindEnclosingMountFinish ::+    (MonadIO m, FileK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- res+    m Mount+fileFindEnclosingMountFinish _obj res = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let res' = unsafeManagedPtrCastPtr res+    onException (do+        result <- propagateGError $ g_file_find_enclosing_mount_finish _obj' res'+        checkUnexpectedReturnNULL "g_file_find_enclosing_mount_finish" result+        result' <- (wrapObject Mount) result+        touchManagedPtr _obj+        touchManagedPtr res+        return result'+     ) (do+        return ()+     )++-- method File::get_basename+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_file_get_basename" g_file_get_basename :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    IO CString+++fileGetBasename ::+    (MonadIO m, FileK a) =>+    a ->                                    -- _obj+    m T.Text+fileGetBasename _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_get_basename _obj'+    checkUnexpectedReturnNULL "g_file_get_basename" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method File::get_child+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "File"+-- throws : False+-- Skip return : False++foreign import ccall "g_file_get_child" g_file_get_child :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr File)+++fileGetChild ::+    (MonadIO m, FileK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- name+    m File+fileGetChild _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name' <- textToCString name+    result <- g_file_get_child _obj' name'+    checkUnexpectedReturnNULL "g_file_get_child" result+    result' <- (wrapObject File) result+    touchManagedPtr _obj+    freeMem name'+    return result'++-- method File::get_child_for_display_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "display_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "display_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "File"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_get_child_for_display_name" g_file_get_child_for_display_name :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CString ->                              -- display_name : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr File)+++fileGetChildForDisplayName ::+    (MonadIO m, FileK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- display_name+    m File+fileGetChildForDisplayName _obj display_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    display_name' <- textToCString display_name+    onException (do+        result <- propagateGError $ g_file_get_child_for_display_name _obj' display_name'+        checkUnexpectedReturnNULL "g_file_get_child_for_display_name" result+        result' <- (wrapObject File) result+        touchManagedPtr _obj+        freeMem display_name'+        return result'+     ) (do+        freeMem display_name'+     )++-- method File::get_parent+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "File"+-- throws : False+-- Skip return : False++foreign import ccall "g_file_get_parent" g_file_get_parent :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    IO (Ptr File)+++fileGetParent ::+    (MonadIO m, FileK a) =>+    a ->                                    -- _obj+    m File+fileGetParent _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_get_parent _obj'+    checkUnexpectedReturnNULL "g_file_get_parent" result+    result' <- (wrapObject File) result+    touchManagedPtr _obj+    return result'++-- method File::get_parse_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_file_get_parse_name" g_file_get_parse_name :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    IO CString+++fileGetParseName ::+    (MonadIO m, FileK a) =>+    a ->                                    -- _obj+    m T.Text+fileGetParseName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_get_parse_name _obj'+    checkUnexpectedReturnNULL "g_file_get_parse_name" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method File::get_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_file_get_path" g_file_get_path :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    IO CString+++fileGetPath ::+    (MonadIO m, FileK a) =>+    a ->                                    -- _obj+    m T.Text+fileGetPath _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_get_path _obj'+    checkUnexpectedReturnNULL "g_file_get_path" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method File::get_relative_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "descendant", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "descendant", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_file_get_relative_path" g_file_get_relative_path :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr File ->                             -- descendant : TInterface "Gio" "File"+    IO CString+++fileGetRelativePath ::+    (MonadIO m, FileK a, FileK b) =>+    a ->                                    -- _obj+    b ->                                    -- descendant+    m T.Text+fileGetRelativePath _obj descendant = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let descendant' = unsafeManagedPtrCastPtr descendant+    result <- g_file_get_relative_path _obj' descendant'+    checkUnexpectedReturnNULL "g_file_get_relative_path" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    touchManagedPtr descendant+    return result'++-- method File::get_uri+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_file_get_uri" g_file_get_uri :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    IO CString+++fileGetUri ::+    (MonadIO m, FileK a) =>+    a ->                                    -- _obj+    m T.Text+fileGetUri _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_get_uri _obj'+    checkUnexpectedReturnNULL "g_file_get_uri" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method File::get_uri_scheme+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_file_get_uri_scheme" g_file_get_uri_scheme :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    IO CString+++fileGetUriScheme ::+    (MonadIO m, FileK a) =>+    a ->                                    -- _obj+    m T.Text+fileGetUriScheme _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_get_uri_scheme _obj'+    checkUnexpectedReturnNULL "g_file_get_uri_scheme" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method File::has_parent+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parent", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parent", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_file_has_parent" g_file_has_parent :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr File ->                             -- parent : TInterface "Gio" "File"+    IO CInt+++fileHasParent ::+    (MonadIO m, FileK a, FileK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- parent+    m Bool+fileHasParent _obj parent = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeParent <- case parent of+        Nothing -> return nullPtr+        Just jParent -> do+            let jParent' = unsafeManagedPtrCastPtr jParent+            return jParent'+    result <- g_file_has_parent _obj' maybeParent+    let result' = (/= 0) result+    touchManagedPtr _obj+    whenJust parent touchManagedPtr+    return result'++-- method File::has_prefix+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "prefix", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "prefix", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_file_has_prefix" g_file_has_prefix :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr File ->                             -- prefix : TInterface "Gio" "File"+    IO CInt+++fileHasPrefix ::+    (MonadIO m, FileK a, FileK b) =>+    a ->                                    -- _obj+    b ->                                    -- prefix+    m Bool+fileHasPrefix _obj prefix = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let prefix' = unsafeManagedPtrCastPtr prefix+    result <- g_file_has_prefix _obj' prefix'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr prefix+    return result'++-- method File::has_uri_scheme+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "uri_scheme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "uri_scheme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_file_has_uri_scheme" g_file_has_uri_scheme :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CString ->                              -- uri_scheme : TBasicType TUTF8+    IO CInt+++fileHasUriScheme ::+    (MonadIO m, FileK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- uri_scheme+    m Bool+fileHasUriScheme _obj uri_scheme = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    uri_scheme' <- textToCString uri_scheme+    result <- g_file_has_uri_scheme _obj' uri_scheme'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem uri_scheme'+    return result'++-- method File::hash+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_file_hash" g_file_hash :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    IO Word32+++fileHash ::+    (MonadIO m, FileK a) =>+    a ->                                    -- _obj+    m Word32+fileHash _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_hash _obj'+    touchManagedPtr _obj+    return result++-- method File::is_native+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_file_is_native" g_file_is_native :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    IO CInt+++fileIsNative ::+    (MonadIO m, FileK a) =>+    a ->                                    -- _obj+    m Bool+fileIsNative _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_is_native _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method File::load_contents+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "contents", argType = TCArray False (-1) 3 (TBasicType TUInt8), direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "etag_out", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : [Arg {argName = "length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_load_contents" g_file_load_contents :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr Word8) ->                      -- contents : TCArray False (-1) 3 (TBasicType TUInt8)+    Ptr Word64 ->                           -- length : TBasicType TUInt64+    Ptr CString ->                          -- etag_out : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileLoadContents ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m (ByteString,T.Text)+fileLoadContents _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    contents <- allocMem :: IO (Ptr (Ptr Word8))+    length_ <- allocMem :: IO (Ptr Word64)+    etag_out <- allocMem :: IO (Ptr CString)+    onException (do+        _ <- propagateGError $ g_file_load_contents _obj' maybeCancellable contents length_ etag_out+        length_' <- peek length_+        contents' <- peek contents+        contents'' <- (unpackByteStringWithLength length_') contents'+        freeMem contents'+        etag_out' <- peek etag_out+        etag_out'' <- cstringToText etag_out'+        freeMem etag_out'+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem contents+        freeMem length_+        freeMem etag_out+        return (contents'', etag_out'')+     ) (do+        freeMem contents+        freeMem length_+        freeMem etag_out+     )++-- method File::load_contents_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_load_contents_async" g_file_load_contents_async :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++fileLoadContentsAsync ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+fileLoadContentsAsync _obj cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_file_load_contents_async _obj' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method File::load_contents_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "contents", argType = TCArray False (-1) 3 (TBasicType TUInt8), direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "etag_out", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : [Arg {argName = "length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_load_contents_finish" g_file_load_contents_finish :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    Ptr (Ptr Word8) ->                      -- contents : TCArray False (-1) 3 (TBasicType TUInt8)+    Ptr Word64 ->                           -- length : TBasicType TUInt64+    Ptr CString ->                          -- etag_out : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileLoadContentsFinish ::+    (MonadIO m, FileK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- res+    m (ByteString,T.Text)+fileLoadContentsFinish _obj res = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let res' = unsafeManagedPtrCastPtr res+    contents <- allocMem :: IO (Ptr (Ptr Word8))+    length_ <- allocMem :: IO (Ptr Word64)+    etag_out <- allocMem :: IO (Ptr CString)+    onException (do+        _ <- propagateGError $ g_file_load_contents_finish _obj' res' contents length_ etag_out+        length_' <- peek length_+        contents' <- peek contents+        contents'' <- (unpackByteStringWithLength length_') contents'+        freeMem contents'+        etag_out' <- peek etag_out+        etag_out'' <- cstringToText etag_out'+        freeMem etag_out'+        touchManagedPtr _obj+        touchManagedPtr res+        freeMem contents+        freeMem length_+        freeMem etag_out+        return (contents'', etag_out'')+     ) (do+        freeMem contents+        freeMem length_+        freeMem etag_out+     )++-- method File::load_partial_contents_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "contents", argType = TCArray False (-1) 3 (TBasicType TUInt8), direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "etag_out", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : [Arg {argName = "length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_load_partial_contents_finish" g_file_load_partial_contents_finish :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    Ptr (Ptr Word8) ->                      -- contents : TCArray False (-1) 3 (TBasicType TUInt8)+    Ptr Word64 ->                           -- length : TBasicType TUInt64+    Ptr CString ->                          -- etag_out : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileLoadPartialContentsFinish ::+    (MonadIO m, FileK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- res+    m (ByteString,T.Text)+fileLoadPartialContentsFinish _obj res = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let res' = unsafeManagedPtrCastPtr res+    contents <- allocMem :: IO (Ptr (Ptr Word8))+    length_ <- allocMem :: IO (Ptr Word64)+    etag_out <- allocMem :: IO (Ptr CString)+    onException (do+        _ <- propagateGError $ g_file_load_partial_contents_finish _obj' res' contents length_ etag_out+        length_' <- peek length_+        contents' <- peek contents+        contents'' <- (unpackByteStringWithLength length_') contents'+        freeMem contents'+        etag_out' <- peek etag_out+        etag_out'' <- cstringToText etag_out'+        freeMem etag_out'+        touchManagedPtr _obj+        touchManagedPtr res+        freeMem contents+        freeMem length_+        freeMem etag_out+        return (contents'', etag_out'')+     ) (do+        freeMem contents+        freeMem length_+        freeMem etag_out+     )++-- method File::make_directory+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_make_directory" g_file_make_directory :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileMakeDirectory ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m ()+fileMakeDirectory _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_file_make_directory _obj' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method File::make_directory_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_make_directory_async" g_file_make_directory_async :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++fileMakeDirectoryAsync ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+fileMakeDirectoryAsync _obj io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_file_make_directory_async _obj' io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method File::make_directory_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_make_directory_finish" g_file_make_directory_finish :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileMakeDirectoryFinish ::+    (MonadIO m, FileK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+fileMakeDirectoryFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_file_make_directory_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++-- method File::make_directory_with_parents+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_make_directory_with_parents" g_file_make_directory_with_parents :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileMakeDirectoryWithParents ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m ()+fileMakeDirectoryWithParents _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_file_make_directory_with_parents _obj' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method File::make_symbolic_link+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "symlink_value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "symlink_value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_make_symbolic_link" g_file_make_symbolic_link :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CString ->                              -- symlink_value : TBasicType TUTF8+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileMakeSymbolicLink ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- symlink_value+    Maybe (b) ->                            -- cancellable+    m ()+fileMakeSymbolicLink _obj symlink_value cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    symlink_value' <- textToCString symlink_value+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_file_make_symbolic_link _obj' symlink_value' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem symlink_value'+        return ()+     ) (do+        freeMem symlink_value'+     )++-- method File::measure_disk_usage_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "disk_usage", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "num_dirs", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "num_files", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_measure_disk_usage_finish" g_file_measure_disk_usage_finish :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr Word64 ->                           -- disk_usage : TBasicType TUInt64+    Ptr Word64 ->                           -- num_dirs : TBasicType TUInt64+    Ptr Word64 ->                           -- num_files : TBasicType TUInt64+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileMeasureDiskUsageFinish ::+    (MonadIO m, FileK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m (Word64,Word64,Word64)+fileMeasureDiskUsageFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    disk_usage <- allocMem :: IO (Ptr Word64)+    num_dirs <- allocMem :: IO (Ptr Word64)+    num_files <- allocMem :: IO (Ptr Word64)+    onException (do+        _ <- propagateGError $ g_file_measure_disk_usage_finish _obj' result_' disk_usage num_dirs num_files+        disk_usage' <- peek disk_usage+        num_dirs' <- peek num_dirs+        num_files' <- peek num_files+        touchManagedPtr _obj+        touchManagedPtr result_+        freeMem disk_usage+        freeMem num_dirs+        freeMem num_files+        return (disk_usage', num_dirs', num_files')+     ) (do+        freeMem disk_usage+        freeMem num_dirs+        freeMem num_files+     )++-- method File::monitor+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileMonitorFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileMonitorFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileMonitor"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_monitor" g_file_monitor :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CUInt ->                                -- flags : TInterface "Gio" "FileMonitorFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr FileMonitor)+++fileMonitor ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    [FileMonitorFlags] ->                   -- flags+    Maybe (b) ->                            -- cancellable+    m FileMonitor+fileMonitor _obj flags cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_file_monitor _obj' flags' maybeCancellable+        checkUnexpectedReturnNULL "g_file_monitor" result+        result' <- (wrapObject FileMonitor) result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )++-- method File::monitor_directory+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileMonitorFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileMonitorFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileMonitor"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_monitor_directory" g_file_monitor_directory :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CUInt ->                                -- flags : TInterface "Gio" "FileMonitorFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr FileMonitor)+++fileMonitorDirectory ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    [FileMonitorFlags] ->                   -- flags+    Maybe (b) ->                            -- cancellable+    m FileMonitor+fileMonitorDirectory _obj flags cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_file_monitor_directory _obj' flags' maybeCancellable+        checkUnexpectedReturnNULL "g_file_monitor_directory" result+        result' <- (wrapObject FileMonitor) result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )++-- method File::monitor_file+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileMonitorFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileMonitorFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileMonitor"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_monitor_file" g_file_monitor_file :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CUInt ->                                -- flags : TInterface "Gio" "FileMonitorFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr FileMonitor)+++fileMonitorFile ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    [FileMonitorFlags] ->                   -- flags+    Maybe (b) ->                            -- cancellable+    m FileMonitor+fileMonitorFile _obj flags cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_file_monitor_file _obj' flags' maybeCancellable+        checkUnexpectedReturnNULL "g_file_monitor_file" result+        result' <- (wrapObject FileMonitor) result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )++-- method File::mount_enclosing_volume+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountMountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mount_operation", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountMountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mount_operation", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_mount_enclosing_volume" g_file_mount_enclosing_volume :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CUInt ->                                -- flags : TInterface "Gio" "MountMountFlags"+    Ptr MountOperation ->                   -- mount_operation : TInterface "Gio" "MountOperation"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++fileMountEnclosingVolume ::+    (MonadIO m, FileK a, MountOperationK b, CancellableK c) =>+    a ->                                    -- _obj+    [MountMountFlags] ->                    -- flags+    Maybe (b) ->                            -- mount_operation+    Maybe (c) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+fileMountEnclosingVolume _obj flags mount_operation cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    maybeMount_operation <- case mount_operation of+        Nothing -> return nullPtr+        Just jMount_operation -> do+            let jMount_operation' = unsafeManagedPtrCastPtr jMount_operation+            return jMount_operation'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_file_mount_enclosing_volume _obj' flags' maybeMount_operation maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust mount_operation touchManagedPtr+    whenJust cancellable touchManagedPtr+    return ()++-- method File::mount_enclosing_volume_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_mount_enclosing_volume_finish" g_file_mount_enclosing_volume_finish :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileMountEnclosingVolumeFinish ::+    (MonadIO m, FileK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+fileMountEnclosingVolumeFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_file_mount_enclosing_volume_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++-- method File::mount_mountable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountMountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mount_operation", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountMountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mount_operation", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_mount_mountable" g_file_mount_mountable :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CUInt ->                                -- flags : TInterface "Gio" "MountMountFlags"+    Ptr MountOperation ->                   -- mount_operation : TInterface "Gio" "MountOperation"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++fileMountMountable ::+    (MonadIO m, FileK a, MountOperationK b, CancellableK c) =>+    a ->                                    -- _obj+    [MountMountFlags] ->                    -- flags+    Maybe (b) ->                            -- mount_operation+    Maybe (c) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+fileMountMountable _obj flags mount_operation cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    maybeMount_operation <- case mount_operation of+        Nothing -> return nullPtr+        Just jMount_operation -> do+            let jMount_operation' = unsafeManagedPtrCastPtr jMount_operation+            return jMount_operation'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_file_mount_mountable _obj' flags' maybeMount_operation maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust mount_operation touchManagedPtr+    whenJust cancellable touchManagedPtr+    return ()++-- method File::mount_mountable_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "File"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_mount_mountable_finish" g_file_mount_mountable_finish :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr File)+++fileMountMountableFinish ::+    (MonadIO m, FileK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m File+fileMountMountableFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        result <- propagateGError $ g_file_mount_mountable_finish _obj' result_'+        checkUnexpectedReturnNULL "g_file_mount_mountable_finish" result+        result' <- (wrapObject File) result+        touchManagedPtr _obj+        touchManagedPtr result_+        return result'+     ) (do+        return ()+     )++-- method File::move+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "destination", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileCopyFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "progress_callback", argType = TInterface "Gio" "FileProgressCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeCall, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "progress_callback_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "destination", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileCopyFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "progress_callback", argType = TInterface "Gio" "FileProgressCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeCall, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_move" g_file_move :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr File ->                             -- destination : TInterface "Gio" "File"+    CUInt ->                                -- flags : TInterface "Gio" "FileCopyFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr FileProgressCallbackC ->         -- progress_callback : TInterface "Gio" "FileProgressCallback"+    Ptr () ->                               -- progress_callback_data : TBasicType TVoid+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileMove ::+    (MonadIO m, FileK a, FileK b, CancellableK c) =>+    a ->                                    -- _obj+    b ->                                    -- destination+    [FileCopyFlags] ->                      -- flags+    Maybe (c) ->                            -- cancellable+    Maybe (FileProgressCallback) ->         -- progress_callback+    m ()+fileMove _obj destination flags cancellable progress_callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let destination' = unsafeManagedPtrCastPtr destination+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    maybeProgress_callback <- case progress_callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jProgress_callback -> do+            jProgress_callback' <- mkFileProgressCallback (fileProgressCallbackWrapper Nothing jProgress_callback)+            return jProgress_callback'+    let progress_callback_data = nullPtr+    onException (do+        _ <- propagateGError $ g_file_move _obj' destination' flags' maybeCancellable maybeProgress_callback progress_callback_data+        safeFreeFunPtr $ castFunPtrToPtr maybeProgress_callback+        touchManagedPtr _obj+        touchManagedPtr destination+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        safeFreeFunPtr $ castFunPtrToPtr maybeProgress_callback+        return ()+     )++-- method File::open_readwrite+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileIOStream"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_open_readwrite" g_file_open_readwrite :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr FileIOStream)+++fileOpenReadwrite ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m FileIOStream+fileOpenReadwrite _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_file_open_readwrite _obj' maybeCancellable+        checkUnexpectedReturnNULL "g_file_open_readwrite" result+        result' <- (wrapObject FileIOStream) result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )++-- method File::open_readwrite_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_open_readwrite_async" g_file_open_readwrite_async :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++fileOpenReadwriteAsync ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+fileOpenReadwriteAsync _obj io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_file_open_readwrite_async _obj' io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method File::open_readwrite_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileIOStream"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_open_readwrite_finish" g_file_open_readwrite_finish :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr FileIOStream)+++fileOpenReadwriteFinish ::+    (MonadIO m, FileK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- res+    m FileIOStream+fileOpenReadwriteFinish _obj res = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let res' = unsafeManagedPtrCastPtr res+    onException (do+        result <- propagateGError $ g_file_open_readwrite_finish _obj' res'+        checkUnexpectedReturnNULL "g_file_open_readwrite_finish" result+        result' <- (wrapObject FileIOStream) result+        touchManagedPtr _obj+        touchManagedPtr res+        return result'+     ) (do+        return ()+     )++-- method File::poll_mountable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_poll_mountable" g_file_poll_mountable :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++filePollMountable ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+filePollMountable _obj cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_file_poll_mountable _obj' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method File::poll_mountable_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_poll_mountable_finish" g_file_poll_mountable_finish :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++filePollMountableFinish ::+    (MonadIO m, FileK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+filePollMountableFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_file_poll_mountable_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++-- method File::query_default_handler+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "AppInfo"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_query_default_handler" g_file_query_default_handler :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr AppInfo)+++fileQueryDefaultHandler ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m AppInfo+fileQueryDefaultHandler _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_file_query_default_handler _obj' maybeCancellable+        checkUnexpectedReturnNULL "g_file_query_default_handler" result+        result' <- (wrapObject AppInfo) result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )++-- method File::query_exists+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_file_query_exists" g_file_query_exists :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    IO CInt+++fileQueryExists ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m Bool+fileQueryExists _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    result <- g_file_query_exists _obj' maybeCancellable+    let result' = (/= 0) result+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return result'++-- method File::query_file_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileQueryInfoFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileQueryInfoFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileType"+-- throws : False+-- Skip return : False++foreign import ccall "g_file_query_file_type" g_file_query_file_type :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CUInt ->                                -- flags : TInterface "Gio" "FileQueryInfoFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    IO CUInt+++fileQueryFileType ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    [FileQueryInfoFlags] ->                 -- flags+    Maybe (b) ->                            -- cancellable+    m FileType+fileQueryFileType _obj flags cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    result <- g_file_query_file_type _obj' flags' maybeCancellable+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return result'++-- method File::query_filesystem_info+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attributes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attributes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileInfo"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_query_filesystem_info" g_file_query_filesystem_info :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CString ->                              -- attributes : TBasicType TUTF8+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr FileInfo)+++fileQueryFilesystemInfo ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- attributes+    Maybe (b) ->                            -- cancellable+    m FileInfo+fileQueryFilesystemInfo _obj attributes cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attributes' <- textToCString attributes+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_file_query_filesystem_info _obj' attributes' maybeCancellable+        checkUnexpectedReturnNULL "g_file_query_filesystem_info" result+        result' <- (wrapObject FileInfo) result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem attributes'+        return result'+     ) (do+        freeMem attributes'+     )++-- method File::query_filesystem_info_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attributes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attributes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_query_filesystem_info_async" g_file_query_filesystem_info_async :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CString ->                              -- attributes : TBasicType TUTF8+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++fileQueryFilesystemInfoAsync ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- attributes+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+fileQueryFilesystemInfoAsync _obj attributes io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attributes' <- textToCString attributes+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_file_query_filesystem_info_async _obj' attributes' io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    freeMem attributes'+    return ()++-- method File::query_filesystem_info_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileInfo"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_query_filesystem_info_finish" g_file_query_filesystem_info_finish :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr FileInfo)+++fileQueryFilesystemInfoFinish ::+    (MonadIO m, FileK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- res+    m FileInfo+fileQueryFilesystemInfoFinish _obj res = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let res' = unsafeManagedPtrCastPtr res+    onException (do+        result <- propagateGError $ g_file_query_filesystem_info_finish _obj' res'+        checkUnexpectedReturnNULL "g_file_query_filesystem_info_finish" result+        result' <- (wrapObject FileInfo) result+        touchManagedPtr _obj+        touchManagedPtr res+        return result'+     ) (do+        return ()+     )++-- method File::query_info+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attributes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileQueryInfoFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attributes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileQueryInfoFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileInfo"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_query_info" g_file_query_info :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CString ->                              -- attributes : TBasicType TUTF8+    CUInt ->                                -- flags : TInterface "Gio" "FileQueryInfoFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr FileInfo)+++fileQueryInfo ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- attributes+    [FileQueryInfoFlags] ->                 -- flags+    Maybe (b) ->                            -- cancellable+    m FileInfo+fileQueryInfo _obj attributes flags cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attributes' <- textToCString attributes+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_file_query_info _obj' attributes' flags' maybeCancellable+        checkUnexpectedReturnNULL "g_file_query_info" result+        result' <- (wrapObject FileInfo) result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem attributes'+        return result'+     ) (do+        freeMem attributes'+     )++-- method File::query_info_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attributes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileQueryInfoFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attributes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileQueryInfoFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_query_info_async" g_file_query_info_async :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CString ->                              -- attributes : TBasicType TUTF8+    CUInt ->                                -- flags : TInterface "Gio" "FileQueryInfoFlags"+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++fileQueryInfoAsync ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- attributes+    [FileQueryInfoFlags] ->                 -- flags+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+fileQueryInfoAsync _obj attributes flags io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attributes' <- textToCString attributes+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_file_query_info_async _obj' attributes' flags' io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    freeMem attributes'+    return ()++-- method File::query_info_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileInfo"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_query_info_finish" g_file_query_info_finish :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr FileInfo)+++fileQueryInfoFinish ::+    (MonadIO m, FileK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- res+    m FileInfo+fileQueryInfoFinish _obj res = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let res' = unsafeManagedPtrCastPtr res+    onException (do+        result <- propagateGError $ g_file_query_info_finish _obj' res'+        checkUnexpectedReturnNULL "g_file_query_info_finish" result+        result' <- (wrapObject FileInfo) result+        touchManagedPtr _obj+        touchManagedPtr res+        return result'+     ) (do+        return ()+     )++-- method File::query_settable_attributes+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileAttributeInfoList"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_query_settable_attributes" g_file_query_settable_attributes :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr FileAttributeInfoList)+++fileQuerySettableAttributes ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m FileAttributeInfoList+fileQuerySettableAttributes _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_file_query_settable_attributes _obj' maybeCancellable+        checkUnexpectedReturnNULL "g_file_query_settable_attributes" result+        result' <- (wrapBoxed FileAttributeInfoList) result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )++-- method File::query_writable_namespaces+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileAttributeInfoList"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_query_writable_namespaces" g_file_query_writable_namespaces :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr FileAttributeInfoList)+++fileQueryWritableNamespaces ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m FileAttributeInfoList+fileQueryWritableNamespaces _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_file_query_writable_namespaces _obj' maybeCancellable+        checkUnexpectedReturnNULL "g_file_query_writable_namespaces" result+        result' <- (wrapBoxed FileAttributeInfoList) result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )++-- method File::read+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileInputStream"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_read" g_file_read :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr FileInputStream)+++fileRead ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m FileInputStream+fileRead _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_file_read _obj' maybeCancellable+        checkUnexpectedReturnNULL "g_file_read" result+        result' <- (wrapObject FileInputStream) result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )++-- method File::read_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_read_async" g_file_read_async :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++fileReadAsync ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+fileReadAsync _obj io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_file_read_async _obj' io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method File::read_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileInputStream"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_read_finish" g_file_read_finish :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr FileInputStream)+++fileReadFinish ::+    (MonadIO m, FileK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- res+    m FileInputStream+fileReadFinish _obj res = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let res' = unsafeManagedPtrCastPtr res+    onException (do+        result <- propagateGError $ g_file_read_finish _obj' res'+        checkUnexpectedReturnNULL "g_file_read_finish" result+        result' <- (wrapObject FileInputStream) result+        touchManagedPtr _obj+        touchManagedPtr res+        return result'+     ) (do+        return ()+     )++-- method File::replace+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "etag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "make_backup", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileCreateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "etag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "make_backup", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileCreateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileOutputStream"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_replace" g_file_replace :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CString ->                              -- etag : TBasicType TUTF8+    CInt ->                                 -- make_backup : TBasicType TBoolean+    CUInt ->                                -- flags : TInterface "Gio" "FileCreateFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr FileOutputStream)+++fileReplace ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- etag+    Bool ->                                 -- make_backup+    [FileCreateFlags] ->                    -- flags+    Maybe (b) ->                            -- cancellable+    m FileOutputStream+fileReplace _obj etag make_backup flags cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeEtag <- case etag of+        Nothing -> return nullPtr+        Just jEtag -> do+            jEtag' <- textToCString jEtag+            return jEtag'+    let make_backup' = (fromIntegral . fromEnum) make_backup+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_file_replace _obj' maybeEtag make_backup' flags' maybeCancellable+        checkUnexpectedReturnNULL "g_file_replace" result+        result' <- (wrapObject FileOutputStream) result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem maybeEtag+        return result'+     ) (do+        freeMem maybeEtag+     )++-- method File::replace_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "etag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "make_backup", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileCreateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 7, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "etag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "make_backup", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileCreateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 7, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_replace_async" g_file_replace_async :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CString ->                              -- etag : TBasicType TUTF8+    CInt ->                                 -- make_backup : TBasicType TBoolean+    CUInt ->                                -- flags : TInterface "Gio" "FileCreateFlags"+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++fileReplaceAsync ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- etag+    Bool ->                                 -- make_backup+    [FileCreateFlags] ->                    -- flags+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+fileReplaceAsync _obj etag make_backup flags io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeEtag <- case etag of+        Nothing -> return nullPtr+        Just jEtag -> do+            jEtag' <- textToCString jEtag+            return jEtag'+    let make_backup' = (fromIntegral . fromEnum) make_backup+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_file_replace_async _obj' maybeEtag make_backup' flags' io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    freeMem maybeEtag+    return ()++-- method File::replace_contents+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "contents", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "length", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "etag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "make_backup", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileCreateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "new_etag", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "length", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "contents", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "etag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "make_backup", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileCreateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_replace_contents" g_file_replace_contents :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr Word8 ->                            -- contents : TCArray False (-1) 2 (TBasicType TUInt8)+    Word64 ->                               -- length : TBasicType TUInt64+    CString ->                              -- etag : TBasicType TUTF8+    CInt ->                                 -- make_backup : TBasicType TBoolean+    CUInt ->                                -- flags : TInterface "Gio" "FileCreateFlags"+    Ptr CString ->                          -- new_etag : TBasicType TUTF8+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileReplaceContents ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    ByteString ->                           -- contents+    Maybe (T.Text) ->                       -- etag+    Bool ->                                 -- make_backup+    [FileCreateFlags] ->                    -- flags+    Maybe (b) ->                            -- cancellable+    m (T.Text)+fileReplaceContents _obj contents etag make_backup flags cancellable = liftIO $ do+    let length_ = fromIntegral $ B.length contents+    let _obj' = unsafeManagedPtrCastPtr _obj+    contents' <- packByteString contents+    maybeEtag <- case etag of+        Nothing -> return nullPtr+        Just jEtag -> do+            jEtag' <- textToCString jEtag+            return jEtag'+    let make_backup' = (fromIntegral . fromEnum) make_backup+    let flags' = gflagsToWord flags+    new_etag <- allocMem :: IO (Ptr CString)+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_file_replace_contents _obj' contents' length_ maybeEtag make_backup' flags' new_etag maybeCancellable+        new_etag' <- peek new_etag+        new_etag'' <- cstringToText new_etag'+        freeMem new_etag'+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem contents'+        freeMem maybeEtag+        freeMem new_etag+        return new_etag''+     ) (do+        freeMem contents'+        freeMem maybeEtag+        freeMem new_etag+     )++-- method File::replace_contents_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "contents", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "length", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "etag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "make_backup", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileCreateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 8, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "length", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "contents", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "etag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "make_backup", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileCreateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 8, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_replace_contents_async" g_file_replace_contents_async :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr Word8 ->                            -- contents : TCArray False (-1) 2 (TBasicType TUInt8)+    Word64 ->                               -- length : TBasicType TUInt64+    CString ->                              -- etag : TBasicType TUTF8+    CInt ->                                 -- make_backup : TBasicType TBoolean+    CUInt ->                                -- flags : TInterface "Gio" "FileCreateFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++fileReplaceContentsAsync ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    ByteString ->                           -- contents+    Maybe (T.Text) ->                       -- etag+    Bool ->                                 -- make_backup+    [FileCreateFlags] ->                    -- flags+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+fileReplaceContentsAsync _obj contents etag make_backup flags cancellable callback = liftIO $ do+    let length_ = fromIntegral $ B.length contents+    let _obj' = unsafeManagedPtrCastPtr _obj+    contents' <- packByteString contents+    maybeEtag <- case etag of+        Nothing -> return nullPtr+        Just jEtag -> do+            jEtag' <- textToCString jEtag+            return jEtag'+    let make_backup' = (fromIntegral . fromEnum) make_backup+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_file_replace_contents_async _obj' contents' length_ maybeEtag make_backup' flags' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    freeMem contents'+    freeMem maybeEtag+    return ()++-- method File::replace_contents_bytes_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "contents", argType = TInterface "GLib" "Bytes", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "etag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "make_backup", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileCreateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 7, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "contents", argType = TInterface "GLib" "Bytes", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "etag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "make_backup", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileCreateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 7, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_replace_contents_bytes_async" g_file_replace_contents_bytes_async :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr GLib.Bytes ->                       -- contents : TInterface "GLib" "Bytes"+    CString ->                              -- etag : TBasicType TUTF8+    CInt ->                                 -- make_backup : TBasicType TBoolean+    CUInt ->                                -- flags : TInterface "Gio" "FileCreateFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++fileReplaceContentsBytesAsync ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    GLib.Bytes ->                           -- contents+    Maybe (T.Text) ->                       -- etag+    Bool ->                                 -- make_backup+    [FileCreateFlags] ->                    -- flags+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+fileReplaceContentsBytesAsync _obj contents etag make_backup flags cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let contents' = unsafeManagedPtrGetPtr contents+    maybeEtag <- case etag of+        Nothing -> return nullPtr+        Just jEtag -> do+            jEtag' <- textToCString jEtag+            return jEtag'+    let make_backup' = (fromIntegral . fromEnum) make_backup+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_file_replace_contents_bytes_async _obj' contents' maybeEtag make_backup' flags' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    touchManagedPtr contents+    whenJust cancellable touchManagedPtr+    freeMem maybeEtag+    return ()++-- method File::replace_contents_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "new_etag", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_replace_contents_finish" g_file_replace_contents_finish :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    Ptr CString ->                          -- new_etag : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileReplaceContentsFinish ::+    (MonadIO m, FileK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- res+    m (T.Text)+fileReplaceContentsFinish _obj res = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let res' = unsafeManagedPtrCastPtr res+    new_etag <- allocMem :: IO (Ptr CString)+    onException (do+        _ <- propagateGError $ g_file_replace_contents_finish _obj' res' new_etag+        new_etag' <- peek new_etag+        new_etag'' <- cstringToText new_etag'+        freeMem new_etag'+        touchManagedPtr _obj+        touchManagedPtr res+        freeMem new_etag+        return new_etag''+     ) (do+        freeMem new_etag+     )++-- method File::replace_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileOutputStream"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_replace_finish" g_file_replace_finish :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr FileOutputStream)+++fileReplaceFinish ::+    (MonadIO m, FileK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- res+    m FileOutputStream+fileReplaceFinish _obj res = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let res' = unsafeManagedPtrCastPtr res+    onException (do+        result <- propagateGError $ g_file_replace_finish _obj' res'+        checkUnexpectedReturnNULL "g_file_replace_finish" result+        result' <- (wrapObject FileOutputStream) result+        touchManagedPtr _obj+        touchManagedPtr res+        return result'+     ) (do+        return ()+     )++-- method File::replace_readwrite+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "etag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "make_backup", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileCreateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "etag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "make_backup", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileCreateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileIOStream"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_replace_readwrite" g_file_replace_readwrite :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CString ->                              -- etag : TBasicType TUTF8+    CInt ->                                 -- make_backup : TBasicType TBoolean+    CUInt ->                                -- flags : TInterface "Gio" "FileCreateFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr FileIOStream)+++fileReplaceReadwrite ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- etag+    Bool ->                                 -- make_backup+    [FileCreateFlags] ->                    -- flags+    Maybe (b) ->                            -- cancellable+    m FileIOStream+fileReplaceReadwrite _obj etag make_backup flags cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeEtag <- case etag of+        Nothing -> return nullPtr+        Just jEtag -> do+            jEtag' <- textToCString jEtag+            return jEtag'+    let make_backup' = (fromIntegral . fromEnum) make_backup+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_file_replace_readwrite _obj' maybeEtag make_backup' flags' maybeCancellable+        checkUnexpectedReturnNULL "g_file_replace_readwrite" result+        result' <- (wrapObject FileIOStream) result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem maybeEtag+        return result'+     ) (do+        freeMem maybeEtag+     )++-- method File::replace_readwrite_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "etag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "make_backup", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileCreateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 7, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "etag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "make_backup", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileCreateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 7, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_replace_readwrite_async" g_file_replace_readwrite_async :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CString ->                              -- etag : TBasicType TUTF8+    CInt ->                                 -- make_backup : TBasicType TBoolean+    CUInt ->                                -- flags : TInterface "Gio" "FileCreateFlags"+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++fileReplaceReadwriteAsync ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- etag+    Bool ->                                 -- make_backup+    [FileCreateFlags] ->                    -- flags+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+fileReplaceReadwriteAsync _obj etag make_backup flags io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeEtag <- case etag of+        Nothing -> return nullPtr+        Just jEtag -> do+            jEtag' <- textToCString jEtag+            return jEtag'+    let make_backup' = (fromIntegral . fromEnum) make_backup+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_file_replace_readwrite_async _obj' maybeEtag make_backup' flags' io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    freeMem maybeEtag+    return ()++-- method File::replace_readwrite_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileIOStream"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_replace_readwrite_finish" g_file_replace_readwrite_finish :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr FileIOStream)+++fileReplaceReadwriteFinish ::+    (MonadIO m, FileK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- res+    m FileIOStream+fileReplaceReadwriteFinish _obj res = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let res' = unsafeManagedPtrCastPtr res+    onException (do+        result <- propagateGError $ g_file_replace_readwrite_finish _obj' res'+        checkUnexpectedReturnNULL "g_file_replace_readwrite_finish" result+        result' <- (wrapObject FileIOStream) result+        touchManagedPtr _obj+        touchManagedPtr res+        return result'+     ) (do+        return ()+     )++-- method File::resolve_relative_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "relative_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "relative_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "File"+-- throws : False+-- Skip return : False++foreign import ccall "g_file_resolve_relative_path" g_file_resolve_relative_path :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CString ->                              -- relative_path : TBasicType TUTF8+    IO (Ptr File)+++fileResolveRelativePath ::+    (MonadIO m, FileK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- relative_path+    m File+fileResolveRelativePath _obj relative_path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    relative_path' <- textToCString relative_path+    result <- g_file_resolve_relative_path _obj' relative_path'+    checkUnexpectedReturnNULL "g_file_resolve_relative_path" result+    result' <- (wrapObject File) result+    touchManagedPtr _obj+    freeMem relative_path'+    return result'++-- method File::set_attribute+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "Gio" "FileAttributeType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value_p", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileQueryInfoFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "Gio" "FileAttributeType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value_p", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileQueryInfoFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_set_attribute" g_file_set_attribute :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CString ->                              -- attribute : TBasicType TUTF8+    CUInt ->                                -- type : TInterface "Gio" "FileAttributeType"+    Ptr () ->                               -- value_p : TBasicType TVoid+    CUInt ->                                -- flags : TInterface "Gio" "FileQueryInfoFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileSetAttribute ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    FileAttributeType ->                    -- type+    Maybe (Ptr ()) ->                       -- value_p+    [FileQueryInfoFlags] ->                 -- flags+    Maybe (b) ->                            -- cancellable+    m ()+fileSetAttribute _obj attribute type_ value_p flags cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    let type_' = (fromIntegral . fromEnum) type_+    maybeValue_p <- case value_p of+        Nothing -> return nullPtr+        Just jValue_p -> do+            return jValue_p+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_file_set_attribute _obj' attribute' type_' maybeValue_p flags' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem attribute'+        return ()+     ) (do+        freeMem attribute'+     )++-- method File::set_attribute_byte_string+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileQueryInfoFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileQueryInfoFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_set_attribute_byte_string" g_file_set_attribute_byte_string :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CString ->                              -- attribute : TBasicType TUTF8+    CString ->                              -- value : TBasicType TUTF8+    CUInt ->                                -- flags : TInterface "Gio" "FileQueryInfoFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileSetAttributeByteString ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    T.Text ->                               -- value+    [FileQueryInfoFlags] ->                 -- flags+    Maybe (b) ->                            -- cancellable+    m ()+fileSetAttributeByteString _obj attribute value flags cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    value' <- textToCString value+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_file_set_attribute_byte_string _obj' attribute' value' flags' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem attribute'+        freeMem value'+        return ()+     ) (do+        freeMem attribute'+        freeMem value'+     )++-- method File::set_attribute_int32+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileQueryInfoFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileQueryInfoFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_set_attribute_int32" g_file_set_attribute_int32 :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CString ->                              -- attribute : TBasicType TUTF8+    Int32 ->                                -- value : TBasicType TInt32+    CUInt ->                                -- flags : TInterface "Gio" "FileQueryInfoFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileSetAttributeInt32 ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    Int32 ->                                -- value+    [FileQueryInfoFlags] ->                 -- flags+    Maybe (b) ->                            -- cancellable+    m ()+fileSetAttributeInt32 _obj attribute value flags cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_file_set_attribute_int32 _obj' attribute' value flags' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem attribute'+        return ()+     ) (do+        freeMem attribute'+     )++-- method File::set_attribute_int64+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileQueryInfoFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileQueryInfoFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_set_attribute_int64" g_file_set_attribute_int64 :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CString ->                              -- attribute : TBasicType TUTF8+    Int64 ->                                -- value : TBasicType TInt64+    CUInt ->                                -- flags : TInterface "Gio" "FileQueryInfoFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileSetAttributeInt64 ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    Int64 ->                                -- value+    [FileQueryInfoFlags] ->                 -- flags+    Maybe (b) ->                            -- cancellable+    m ()+fileSetAttributeInt64 _obj attribute value flags cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_file_set_attribute_int64 _obj' attribute' value flags' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem attribute'+        return ()+     ) (do+        freeMem attribute'+     )++-- method File::set_attribute_string+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileQueryInfoFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileQueryInfoFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_set_attribute_string" g_file_set_attribute_string :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CString ->                              -- attribute : TBasicType TUTF8+    CString ->                              -- value : TBasicType TUTF8+    CUInt ->                                -- flags : TInterface "Gio" "FileQueryInfoFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileSetAttributeString ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    T.Text ->                               -- value+    [FileQueryInfoFlags] ->                 -- flags+    Maybe (b) ->                            -- cancellable+    m ()+fileSetAttributeString _obj attribute value flags cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    value' <- textToCString value+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_file_set_attribute_string _obj' attribute' value' flags' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem attribute'+        freeMem value'+        return ()+     ) (do+        freeMem attribute'+        freeMem value'+     )++-- method File::set_attribute_uint32+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileQueryInfoFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileQueryInfoFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_set_attribute_uint32" g_file_set_attribute_uint32 :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CString ->                              -- attribute : TBasicType TUTF8+    Word32 ->                               -- value : TBasicType TUInt32+    CUInt ->                                -- flags : TInterface "Gio" "FileQueryInfoFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileSetAttributeUint32 ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    Word32 ->                               -- value+    [FileQueryInfoFlags] ->                 -- flags+    Maybe (b) ->                            -- cancellable+    m ()+fileSetAttributeUint32 _obj attribute value flags cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_file_set_attribute_uint32 _obj' attribute' value flags' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem attribute'+        return ()+     ) (do+        freeMem attribute'+     )++-- method File::set_attribute_uint64+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileQueryInfoFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileQueryInfoFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_set_attribute_uint64" g_file_set_attribute_uint64 :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CString ->                              -- attribute : TBasicType TUTF8+    Word64 ->                               -- value : TBasicType TUInt64+    CUInt ->                                -- flags : TInterface "Gio" "FileQueryInfoFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileSetAttributeUint64 ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    Word64 ->                               -- value+    [FileQueryInfoFlags] ->                 -- flags+    Maybe (b) ->                            -- cancellable+    m ()+fileSetAttributeUint64 _obj attribute value flags cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_file_set_attribute_uint64 _obj' attribute' value flags' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem attribute'+        return ()+     ) (do+        freeMem attribute'+     )++-- method File::set_attributes_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "info", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileQueryInfoFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "info", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileQueryInfoFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_set_attributes_async" g_file_set_attributes_async :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr FileInfo ->                         -- info : TInterface "Gio" "FileInfo"+    CUInt ->                                -- flags : TInterface "Gio" "FileQueryInfoFlags"+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++fileSetAttributesAsync ::+    (MonadIO m, FileK a, FileInfoK b, CancellableK c) =>+    a ->                                    -- _obj+    b ->                                    -- info+    [FileQueryInfoFlags] ->                 -- flags+    Int32 ->                                -- io_priority+    Maybe (c) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+fileSetAttributesAsync _obj info flags io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let info' = unsafeManagedPtrCastPtr info+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_file_set_attributes_async _obj' info' flags' io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    touchManagedPtr info+    whenJust cancellable touchManagedPtr+    return ()++-- method File::set_attributes_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "info", argType = TInterface "Gio" "FileInfo", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_set_attributes_finish" g_file_set_attributes_finish :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr FileInfo) ->                   -- info : TInterface "Gio" "FileInfo"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileSetAttributesFinish ::+    (MonadIO m, FileK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m (FileInfo)+fileSetAttributesFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    info <- allocMem :: IO (Ptr (Ptr FileInfo))+    onException (do+        _ <- propagateGError $ g_file_set_attributes_finish _obj' result_' info+        info' <- peek info+        info'' <- (wrapObject FileInfo) info'+        touchManagedPtr _obj+        touchManagedPtr result_+        freeMem info+        return info''+     ) (do+        freeMem info+     )++-- method File::set_attributes_from_info+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "info", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileQueryInfoFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "info", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileQueryInfoFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_set_attributes_from_info" g_file_set_attributes_from_info :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr FileInfo ->                         -- info : TInterface "Gio" "FileInfo"+    CUInt ->                                -- flags : TInterface "Gio" "FileQueryInfoFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileSetAttributesFromInfo ::+    (MonadIO m, FileK a, FileInfoK b, CancellableK c) =>+    a ->                                    -- _obj+    b ->                                    -- info+    [FileQueryInfoFlags] ->                 -- flags+    Maybe (c) ->                            -- cancellable+    m ()+fileSetAttributesFromInfo _obj info flags cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let info' = unsafeManagedPtrCastPtr info+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_file_set_attributes_from_info _obj' info' flags' maybeCancellable+        touchManagedPtr _obj+        touchManagedPtr info+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method File::set_display_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "display_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "display_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "File"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_set_display_name" g_file_set_display_name :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CString ->                              -- display_name : TBasicType TUTF8+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr File)+++fileSetDisplayName ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- display_name+    Maybe (b) ->                            -- cancellable+    m File+fileSetDisplayName _obj display_name cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    display_name' <- textToCString display_name+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_file_set_display_name _obj' display_name' maybeCancellable+        checkUnexpectedReturnNULL "g_file_set_display_name" result+        result' <- (wrapObject File) result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem display_name'+        return result'+     ) (do+        freeMem display_name'+     )++-- method File::set_display_name_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "display_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "display_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_set_display_name_async" g_file_set_display_name_async :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CString ->                              -- display_name : TBasicType TUTF8+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++fileSetDisplayNameAsync ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- display_name+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+fileSetDisplayNameAsync _obj display_name io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    display_name' <- textToCString display_name+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_file_set_display_name_async _obj' display_name' io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    freeMem display_name'+    return ()++-- method File::set_display_name_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "File"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_set_display_name_finish" g_file_set_display_name_finish :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr File)+++fileSetDisplayNameFinish ::+    (MonadIO m, FileK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- res+    m File+fileSetDisplayNameFinish _obj res = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let res' = unsafeManagedPtrCastPtr res+    onException (do+        result <- propagateGError $ g_file_set_display_name_finish _obj' res'+        checkUnexpectedReturnNULL "g_file_set_display_name_finish" result+        result' <- (wrapObject File) result+        touchManagedPtr _obj+        touchManagedPtr res+        return result'+     ) (do+        return ()+     )++-- method File::start_mountable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DriveStartFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "start_operation", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DriveStartFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "start_operation", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_start_mountable" g_file_start_mountable :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CUInt ->                                -- flags : TInterface "Gio" "DriveStartFlags"+    Ptr MountOperation ->                   -- start_operation : TInterface "Gio" "MountOperation"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++fileStartMountable ::+    (MonadIO m, FileK a, MountOperationK b, CancellableK c) =>+    a ->                                    -- _obj+    [DriveStartFlags] ->                    -- flags+    Maybe (b) ->                            -- start_operation+    Maybe (c) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+fileStartMountable _obj flags start_operation cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    maybeStart_operation <- case start_operation of+        Nothing -> return nullPtr+        Just jStart_operation -> do+            let jStart_operation' = unsafeManagedPtrCastPtr jStart_operation+            return jStart_operation'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_file_start_mountable _obj' flags' maybeStart_operation maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust start_operation touchManagedPtr+    whenJust cancellable touchManagedPtr+    return ()++-- method File::start_mountable_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_start_mountable_finish" g_file_start_mountable_finish :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileStartMountableFinish ::+    (MonadIO m, FileK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+fileStartMountableFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_file_start_mountable_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++-- method File::stop_mountable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountUnmountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mount_operation", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountUnmountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mount_operation", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_stop_mountable" g_file_stop_mountable :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CUInt ->                                -- flags : TInterface "Gio" "MountUnmountFlags"+    Ptr MountOperation ->                   -- mount_operation : TInterface "Gio" "MountOperation"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++fileStopMountable ::+    (MonadIO m, FileK a, MountOperationK b, CancellableK c) =>+    a ->                                    -- _obj+    [MountUnmountFlags] ->                  -- flags+    Maybe (b) ->                            -- mount_operation+    Maybe (c) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+fileStopMountable _obj flags mount_operation cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    maybeMount_operation <- case mount_operation of+        Nothing -> return nullPtr+        Just jMount_operation -> do+            let jMount_operation' = unsafeManagedPtrCastPtr jMount_operation+            return jMount_operation'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_file_stop_mountable _obj' flags' maybeMount_operation maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust mount_operation touchManagedPtr+    whenJust cancellable touchManagedPtr+    return ()++-- method File::stop_mountable_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_stop_mountable_finish" g_file_stop_mountable_finish :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileStopMountableFinish ::+    (MonadIO m, FileK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+fileStopMountableFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_file_stop_mountable_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++-- method File::supports_thread_contexts+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_file_supports_thread_contexts" g_file_supports_thread_contexts :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    IO CInt+++fileSupportsThreadContexts ::+    (MonadIO m, FileK a) =>+    a ->                                    -- _obj+    m Bool+fileSupportsThreadContexts _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_supports_thread_contexts _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method File::trash+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_trash" g_file_trash :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileTrash ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m ()+fileTrash _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_file_trash _obj' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method File::trash_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_trash_async" g_file_trash_async :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++fileTrashAsync ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+fileTrashAsync _obj io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_file_trash_async _obj' io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method File::trash_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_trash_finish" g_file_trash_finish :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileTrashFinish ::+    (MonadIO m, FileK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+fileTrashFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_file_trash_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++-- method File::unmount_mountable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountUnmountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountUnmountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_unmount_mountable" g_file_unmount_mountable :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CUInt ->                                -- flags : TInterface "Gio" "MountUnmountFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()++{-# DEPRECATED fileUnmountMountable ["(Since version 2.22)","Use g_file_unmount_mountable_with_operation() instead."]#-}+fileUnmountMountable ::+    (MonadIO m, FileK a, CancellableK b) =>+    a ->                                    -- _obj+    [MountUnmountFlags] ->                  -- flags+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+fileUnmountMountable _obj flags cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_file_unmount_mountable _obj' flags' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method File::unmount_mountable_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_unmount_mountable_finish" g_file_unmount_mountable_finish :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt++{-# DEPRECATED fileUnmountMountableFinish ["(Since version 2.22)","Use g_file_unmount_mountable_with_operation_finish()","    instead."]#-}+fileUnmountMountableFinish ::+    (MonadIO m, FileK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+fileUnmountMountableFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_file_unmount_mountable_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++-- method File::unmount_mountable_with_operation+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountUnmountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mount_operation", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountUnmountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mount_operation", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_unmount_mountable_with_operation" g_file_unmount_mountable_with_operation :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    CUInt ->                                -- flags : TInterface "Gio" "MountUnmountFlags"+    Ptr MountOperation ->                   -- mount_operation : TInterface "Gio" "MountOperation"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++fileUnmountMountableWithOperation ::+    (MonadIO m, FileK a, MountOperationK b, CancellableK c) =>+    a ->                                    -- _obj+    [MountUnmountFlags] ->                  -- flags+    Maybe (b) ->                            -- mount_operation+    Maybe (c) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+fileUnmountMountableWithOperation _obj flags mount_operation cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    maybeMount_operation <- case mount_operation of+        Nothing -> return nullPtr+        Just jMount_operation -> do+            let jMount_operation' = unsafeManagedPtrCastPtr jMount_operation+            return jMount_operation'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_file_unmount_mountable_with_operation _obj' flags' maybeMount_operation maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust mount_operation touchManagedPtr+    whenJust cancellable touchManagedPtr+    return ()++-- method File::unmount_mountable_with_operation_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_unmount_mountable_with_operation_finish" g_file_unmount_mountable_with_operation_finish :: +    Ptr File ->                             -- _obj : TInterface "Gio" "File"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileUnmountMountableWithOperationFinish ::+    (MonadIO m, FileK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+fileUnmountMountableWithOperationFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_file_unmount_mountable_with_operation_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++
+ GI/Gio/Interfaces/File.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Interfaces.File where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype File = File (ForeignPtr File)+instance GObject File where+class GObject o => FileK o+instance (GObject o, IsDescendantOf File o) => FileK o
+ GI/Gio/Interfaces/FileDescriptorBased.hs view
@@ -0,0 +1,91 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Interfaces.FileDescriptorBased+    ( ++-- * Exported types+    FileDescriptorBased(..)                 ,+    noFileDescriptorBased                   ,+    FileDescriptorBasedK                    ,+    toFileDescriptorBased                   ,+++ -- * Methods+-- ** fileDescriptorBasedGetFd+    fileDescriptorBasedGetFd                ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++-- interface FileDescriptorBased ++newtype FileDescriptorBased = FileDescriptorBased (ForeignPtr FileDescriptorBased)+noFileDescriptorBased :: Maybe FileDescriptorBased+noFileDescriptorBased = Nothing++type instance AttributeList FileDescriptorBased = FileDescriptorBasedAttributeList+type FileDescriptorBasedAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList FileDescriptorBased = FileDescriptorBasedSignalList+type FileDescriptorBasedSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "g_file_descriptor_based_get_type"+    c_g_file_descriptor_based_get_type :: IO GType++type instance ParentTypes FileDescriptorBased = FileDescriptorBasedParentTypes+type FileDescriptorBasedParentTypes = '[GObject.Object]++instance GObject FileDescriptorBased where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_file_descriptor_based_get_type+    ++class GObject o => FileDescriptorBasedK o+instance (GObject o, IsDescendantOf FileDescriptorBased o) => FileDescriptorBasedK o++toFileDescriptorBased :: FileDescriptorBasedK o => o -> IO FileDescriptorBased+toFileDescriptorBased = unsafeCastTo FileDescriptorBased++-- method FileDescriptorBased::get_fd+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileDescriptorBased", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileDescriptorBased", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_file_descriptor_based_get_fd" g_file_descriptor_based_get_fd :: +    Ptr FileDescriptorBased ->              -- _obj : TInterface "Gio" "FileDescriptorBased"+    IO Int32+++fileDescriptorBasedGetFd ::+    (MonadIO m, FileDescriptorBasedK a) =>+    a ->                                    -- _obj+    m Int32+fileDescriptorBasedGetFd _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_descriptor_based_get_fd _obj'+    touchManagedPtr _obj+    return result++
+ GI/Gio/Interfaces/FileDescriptorBased.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Interfaces.FileDescriptorBased where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype FileDescriptorBased = FileDescriptorBased (ForeignPtr FileDescriptorBased)+instance GObject FileDescriptorBased where+class GObject o => FileDescriptorBasedK o+instance (GObject o, IsDescendantOf FileDescriptorBased o) => FileDescriptorBasedK o
+ GI/Gio/Interfaces/Icon.hs view
@@ -0,0 +1,161 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Interfaces.Icon+    ( ++-- * Exported types+    Icon(..)                                ,+    noIcon                                  ,+    IconK                                   ,+    toIcon                                  ,+++ -- * Methods+-- ** iconEqual+    iconEqual                               ,+++-- ** iconSerialize+    iconSerialize                           ,+++-- ** iconToString+    iconToString                            ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++-- interface Icon ++newtype Icon = Icon (ForeignPtr Icon)+noIcon :: Maybe Icon+noIcon = Nothing++type instance AttributeList Icon = IconAttributeList+type IconAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList Icon = IconSignalList+type IconSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "g_icon_get_type"+    c_g_icon_get_type :: IO GType++type instance ParentTypes Icon = IconParentTypes+type IconParentTypes = '[GObject.Object]++instance GObject Icon where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_icon_get_type+    ++class GObject o => IconK o+instance (GObject o, IsDescendantOf Icon o) => IconK o++toIcon :: IconK o => o -> IO Icon+toIcon = unsafeCastTo Icon++-- method Icon::equal+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Icon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon2", argType = TInterface "Gio" "Icon", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Icon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon2", argType = TInterface "Gio" "Icon", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_icon_equal" g_icon_equal :: +    Ptr Icon ->                             -- _obj : TInterface "Gio" "Icon"+    Ptr Icon ->                             -- icon2 : TInterface "Gio" "Icon"+    IO CInt+++iconEqual ::+    (MonadIO m, IconK a, IconK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- icon2+    m Bool+iconEqual _obj icon2 = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeIcon2 <- case icon2 of+        Nothing -> return nullPtr+        Just jIcon2 -> do+            let jIcon2' = unsafeManagedPtrCastPtr jIcon2+            return jIcon2'+    result <- g_icon_equal _obj' maybeIcon2+    let result' = (/= 0) result+    touchManagedPtr _obj+    whenJust icon2 touchManagedPtr+    return result'++-- method Icon::serialize+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Icon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Icon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TVariant+-- throws : False+-- Skip return : False++foreign import ccall "g_icon_serialize" g_icon_serialize :: +    Ptr Icon ->                             -- _obj : TInterface "Gio" "Icon"+    IO (Ptr GVariant)+++iconSerialize ::+    (MonadIO m, IconK a) =>+    a ->                                    -- _obj+    m GVariant+iconSerialize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_icon_serialize _obj'+    checkUnexpectedReturnNULL "g_icon_serialize" result+    result' <- wrapGVariantPtr result+    touchManagedPtr _obj+    return result'++-- method Icon::to_string+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Icon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Icon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_icon_to_string" g_icon_to_string :: +    Ptr Icon ->                             -- _obj : TInterface "Gio" "Icon"+    IO CString+++iconToString ::+    (MonadIO m, IconK a) =>+    a ->                                    -- _obj+    m T.Text+iconToString _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_icon_to_string _obj'+    checkUnexpectedReturnNULL "g_icon_to_string" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++
+ GI/Gio/Interfaces/Icon.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Interfaces.Icon where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Icon = Icon (ForeignPtr Icon)+instance GObject Icon where+class GObject o => IconK o+instance (GObject o, IsDescendantOf Icon o) => IconK o
+ GI/Gio/Interfaces/Initable.hs view
@@ -0,0 +1,104 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Interfaces.Initable+    ( ++-- * Exported types+    Initable(..)                            ,+    noInitable                              ,+    InitableK                               ,+    toInitable                              ,+++ -- * Methods+-- ** initableInit+    initableInit                            ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++-- interface Initable ++newtype Initable = Initable (ForeignPtr Initable)+noInitable :: Maybe Initable+noInitable = Nothing++type instance AttributeList Initable = InitableAttributeList+type InitableAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList Initable = InitableSignalList+type InitableSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "g_initable_get_type"+    c_g_initable_get_type :: IO GType++type instance ParentTypes Initable = InitableParentTypes+type InitableParentTypes = '[GObject.Object]++instance GObject Initable where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_initable_get_type+    ++class GObject o => InitableK o+instance (GObject o, IsDescendantOf Initable o) => InitableK o++toInitable :: InitableK o => o -> IO Initable+toInitable = unsafeCastTo Initable++-- method Initable::init+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Initable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Initable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_initable_init" g_initable_init :: +    Ptr Initable ->                         -- _obj : TInterface "Gio" "Initable"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++initableInit ::+    (MonadIO m, InitableK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m ()+initableInit _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_initable_init _obj' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++
+ GI/Gio/Interfaces/Initable.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Interfaces.Initable where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Initable = Initable (ForeignPtr Initable)+instance GObject Initable where+class GObject o => InitableK o+instance (GObject o, IsDescendantOf Initable o) => InitableK o
+ GI/Gio/Interfaces/ListModel.hs view
@@ -0,0 +1,253 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Interfaces.ListModel+    ( ++-- * Exported types+    ListModel(..)                           ,+    noListModel                             ,+    ListModelK                              ,+    toListModel                             ,+++ -- * Methods+-- ** listModelGetItem+    listModelGetItem                        ,+++-- ** listModelGetItemType+    listModelGetItemType                    ,+++-- ** listModelGetNItems+    listModelGetNItems                      ,+++-- ** listModelItemsChanged+    listModelItemsChanged                   ,+++++ -- * Signals+-- ** ItemsChanged+    ListModelItemsChangedCallback           ,+    ListModelItemsChangedCallbackC          ,+    ListModelItemsChangedSignalInfo         ,+    afterListModelItemsChanged              ,+    listModelItemsChangedCallbackWrapper    ,+    listModelItemsChangedClosure            ,+    mkListModelItemsChangedCallback         ,+    noListModelItemsChangedCallback         ,+    onListModelItemsChanged                 ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++-- interface ListModel ++newtype ListModel = ListModel (ForeignPtr ListModel)+noListModel :: Maybe ListModel+noListModel = Nothing++-- signal ListModel::items-changed+type ListModelItemsChangedCallback =+    Word32 ->+    Word32 ->+    Word32 ->+    IO ()++noListModelItemsChangedCallback :: Maybe ListModelItemsChangedCallback+noListModelItemsChangedCallback = Nothing++type ListModelItemsChangedCallbackC =+    Ptr () ->                               -- object+    Word32 ->+    Word32 ->+    Word32 ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkListModelItemsChangedCallback :: ListModelItemsChangedCallbackC -> IO (FunPtr ListModelItemsChangedCallbackC)++listModelItemsChangedClosure :: ListModelItemsChangedCallback -> IO Closure+listModelItemsChangedClosure cb = newCClosure =<< mkListModelItemsChangedCallback wrapped+    where wrapped = listModelItemsChangedCallbackWrapper cb++listModelItemsChangedCallbackWrapper ::+    ListModelItemsChangedCallback ->+    Ptr () ->+    Word32 ->+    Word32 ->+    Word32 ->+    Ptr () ->+    IO ()+listModelItemsChangedCallbackWrapper _cb _ position removed added _ = do+    _cb  position removed added++onListModelItemsChanged :: (GObject a, MonadIO m) => a -> ListModelItemsChangedCallback -> m SignalHandlerId+onListModelItemsChanged obj cb = liftIO $ connectListModelItemsChanged obj cb SignalConnectBefore+afterListModelItemsChanged :: (GObject a, MonadIO m) => a -> ListModelItemsChangedCallback -> m SignalHandlerId+afterListModelItemsChanged obj cb = connectListModelItemsChanged obj cb SignalConnectAfter++connectListModelItemsChanged :: (GObject a, MonadIO m) =>+                                a -> ListModelItemsChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectListModelItemsChanged obj cb after = liftIO $ do+    cb' <- mkListModelItemsChangedCallback (listModelItemsChangedCallbackWrapper cb)+    connectSignalFunPtr obj "items-changed" cb' after++type instance AttributeList ListModel = ListModelAttributeList+type ListModelAttributeList = ('[ ] :: [(Symbol, *)])++data ListModelItemsChangedSignalInfo+instance SignalInfo ListModelItemsChangedSignalInfo where+    type HaskellCallbackType ListModelItemsChangedSignalInfo = ListModelItemsChangedCallback+    connectSignal _ = connectListModelItemsChanged++type instance SignalList ListModel = ListModelSignalList+type ListModelSignalList = ('[ '("items-changed", ListModelItemsChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "g_list_model_get_type"+    c_g_list_model_get_type :: IO GType++type instance ParentTypes ListModel = ListModelParentTypes+type ListModelParentTypes = '[GObject.Object]++instance GObject ListModel where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_list_model_get_type+    ++class GObject o => ListModelK o+instance (GObject o, IsDescendantOf ListModel o) => ListModelK o++toListModel :: ListModelK o => o -> IO ListModel+toListModel = unsafeCastTo ListModel++-- method ListModel::get_item_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ListModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ListModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TGType+-- throws : False+-- Skip return : False++foreign import ccall "g_list_model_get_item_type" g_list_model_get_item_type :: +    Ptr ListModel ->                        -- _obj : TInterface "Gio" "ListModel"+    IO CGType+++listModelGetItemType ::+    (MonadIO m, ListModelK a) =>+    a ->                                    -- _obj+    m GType+listModelGetItemType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_list_model_get_item_type _obj'+    let result' = GType result+    touchManagedPtr _obj+    return result'++-- method ListModel::get_n_items+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ListModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ListModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_list_model_get_n_items" g_list_model_get_n_items :: +    Ptr ListModel ->                        -- _obj : TInterface "Gio" "ListModel"+    IO Word32+++listModelGetNItems ::+    (MonadIO m, ListModelK a) =>+    a ->                                    -- _obj+    m Word32+listModelGetNItems _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_list_model_get_n_items _obj'+    touchManagedPtr _obj+    return result++-- method ListModel::get_item+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ListModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ListModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GObject" "Object"+-- throws : False+-- Skip return : False++foreign import ccall "g_list_model_get_object" g_list_model_get_object :: +    Ptr ListModel ->                        -- _obj : TInterface "Gio" "ListModel"+    Word32 ->                               -- position : TBasicType TUInt32+    IO (Ptr GObject.Object)+++listModelGetItem ::+    (MonadIO m, ListModelK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- position+    m GObject.Object+listModelGetItem _obj position = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_list_model_get_object _obj' position+    checkUnexpectedReturnNULL "g_list_model_get_object" result+    result' <- (wrapObject GObject.Object) result+    touchManagedPtr _obj+    return result'++-- method ListModel::items_changed+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ListModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "removed", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "added", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ListModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "removed", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "added", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_list_model_items_changed" g_list_model_items_changed :: +    Ptr ListModel ->                        -- _obj : TInterface "Gio" "ListModel"+    Word32 ->                               -- position : TBasicType TUInt32+    Word32 ->                               -- removed : TBasicType TUInt32+    Word32 ->                               -- added : TBasicType TUInt32+    IO ()+++listModelItemsChanged ::+    (MonadIO m, ListModelK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- position+    Word32 ->                               -- removed+    Word32 ->                               -- added+    m ()+listModelItemsChanged _obj position removed added = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_list_model_items_changed _obj' position removed added+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Interfaces/ListModel.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gio.Interfaces.ListModel where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype ListModel = ListModel (ForeignPtr ListModel)+data ListModelItemsChangedSignalInfo+instance GObject ListModel where+class GObject o => ListModelK o+instance (GObject o, IsDescendantOf ListModel o) => ListModelK o
+ GI/Gio/Interfaces/LoadableIcon.hs view
@@ -0,0 +1,208 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Interfaces.LoadableIcon+    ( ++-- * Exported types+    LoadableIcon(..)                        ,+    noLoadableIcon                          ,+    LoadableIconK                           ,+    toLoadableIcon                          ,+++ -- * Methods+-- ** loadableIconLoad+    loadableIconLoad                        ,+++-- ** loadableIconLoadAsync+    loadableIconLoadAsync                   ,+++-- ** loadableIconLoadFinish+    loadableIconLoadFinish                  ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++-- interface LoadableIcon ++newtype LoadableIcon = LoadableIcon (ForeignPtr LoadableIcon)+noLoadableIcon :: Maybe LoadableIcon+noLoadableIcon = Nothing++type instance AttributeList LoadableIcon = LoadableIconAttributeList+type LoadableIconAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList LoadableIcon = LoadableIconSignalList+type LoadableIconSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "g_loadable_icon_get_type"+    c_g_loadable_icon_get_type :: IO GType++type instance ParentTypes LoadableIcon = LoadableIconParentTypes+type LoadableIconParentTypes = '[Icon, GObject.Object]++instance GObject LoadableIcon where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_loadable_icon_get_type+    ++class GObject o => LoadableIconK o+instance (GObject o, IsDescendantOf LoadableIcon o) => LoadableIconK o++toLoadableIcon :: LoadableIconK o => o -> IO LoadableIcon+toLoadableIcon = unsafeCastTo LoadableIcon++-- method LoadableIcon::load+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "LoadableIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "LoadableIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "InputStream"+-- throws : True+-- Skip return : False++foreign import ccall "g_loadable_icon_load" g_loadable_icon_load :: +    Ptr LoadableIcon ->                     -- _obj : TInterface "Gio" "LoadableIcon"+    Int32 ->                                -- size : TBasicType TInt32+    Ptr CString ->                          -- type : TBasicType TUTF8+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr InputStream)+++loadableIconLoad ::+    (MonadIO m, LoadableIconK a, CancellableK b) =>+    a ->                                    -- _obj+    Int32 ->                                -- size+    Maybe (b) ->                            -- cancellable+    m (InputStream,T.Text)+loadableIconLoad _obj size cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    type_ <- allocMem :: IO (Ptr CString)+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_loadable_icon_load _obj' size type_ maybeCancellable+        checkUnexpectedReturnNULL "g_loadable_icon_load" result+        result' <- (wrapObject InputStream) result+        type_' <- peek type_+        type_'' <- cstringToText type_'+        freeMem type_'+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem type_+        return (result', type_'')+     ) (do+        freeMem type_+     )++-- method LoadableIcon::load_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "LoadableIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "LoadableIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_loadable_icon_load_async" g_loadable_icon_load_async :: +    Ptr LoadableIcon ->                     -- _obj : TInterface "Gio" "LoadableIcon"+    Int32 ->                                -- size : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++loadableIconLoadAsync ::+    (MonadIO m, LoadableIconK a, CancellableK b) =>+    a ->                                    -- _obj+    Int32 ->                                -- size+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+loadableIconLoadAsync _obj size cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_loadable_icon_load_async _obj' size maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method LoadableIcon::load_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "LoadableIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "LoadableIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "InputStream"+-- throws : True+-- Skip return : False++foreign import ccall "g_loadable_icon_load_finish" g_loadable_icon_load_finish :: +    Ptr LoadableIcon ->                     -- _obj : TInterface "Gio" "LoadableIcon"+    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    Ptr CString ->                          -- type : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr InputStream)+++loadableIconLoadFinish ::+    (MonadIO m, LoadableIconK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- res+    m (InputStream,T.Text)+loadableIconLoadFinish _obj res = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let res' = unsafeManagedPtrCastPtr res+    type_ <- allocMem :: IO (Ptr CString)+    onException (do+        result <- propagateGError $ g_loadable_icon_load_finish _obj' res' type_+        checkUnexpectedReturnNULL "g_loadable_icon_load_finish" result+        result' <- (wrapObject InputStream) result+        type_' <- peek type_+        type_'' <- cstringToText type_'+        freeMem type_'+        touchManagedPtr _obj+        touchManagedPtr res+        freeMem type_+        return (result', type_'')+     ) (do+        freeMem type_+     )++
+ GI/Gio/Interfaces/LoadableIcon.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Interfaces.LoadableIcon where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype LoadableIcon = LoadableIcon (ForeignPtr LoadableIcon)+instance GObject LoadableIcon where+class GObject o => LoadableIconK o+instance (GObject o, IsDescendantOf LoadableIcon o) => LoadableIconK o
+ GI/Gio/Interfaces/Mount.hs view
@@ -0,0 +1,1244 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Interfaces.Mount+    ( ++-- * Exported types+    Mount(..)                               ,+    noMount                                 ,+    MountK                                  ,+    toMount                                 ,+++ -- * Methods+-- ** mountCanEject+    mountCanEject                           ,+++-- ** mountCanUnmount+    mountCanUnmount                         ,+++-- ** mountEject+    mountEject                              ,+++-- ** mountEjectFinish+    mountEjectFinish                        ,+++-- ** mountEjectWithOperation+    mountEjectWithOperation                 ,+++-- ** mountEjectWithOperationFinish+    mountEjectWithOperationFinish           ,+++-- ** mountGetDefaultLocation+    mountGetDefaultLocation                 ,+++-- ** mountGetDrive+    mountGetDrive                           ,+++-- ** mountGetIcon+    mountGetIcon                            ,+++-- ** mountGetName+    mountGetName                            ,+++-- ** mountGetRoot+    mountGetRoot                            ,+++-- ** mountGetSortKey+    mountGetSortKey                         ,+++-- ** mountGetSymbolicIcon+    mountGetSymbolicIcon                    ,+++-- ** mountGetUuid+    mountGetUuid                            ,+++-- ** mountGetVolume+    mountGetVolume                          ,+++-- ** mountGuessContentType+    mountGuessContentType                   ,+++-- ** mountGuessContentTypeFinish+    mountGuessContentTypeFinish             ,+++-- ** mountGuessContentTypeSync+    mountGuessContentTypeSync               ,+++-- ** mountIsShadowed+    mountIsShadowed                         ,+++-- ** mountRemount+    mountRemount                            ,+++-- ** mountRemountFinish+    mountRemountFinish                      ,+++-- ** mountShadow+    mountShadow                             ,+++-- ** mountUnmount+    mountUnmount                            ,+++-- ** mountUnmountFinish+    mountUnmountFinish                      ,+++-- ** mountUnmountWithOperation+    mountUnmountWithOperation               ,+++-- ** mountUnmountWithOperationFinish+    mountUnmountWithOperationFinish         ,+++-- ** mountUnshadow+    mountUnshadow                           ,+++++ -- * Signals+-- ** Changed+    MountChangedCallback                    ,+    MountChangedCallbackC                   ,+    MountChangedSignalInfo                  ,+    afterMountChanged                       ,+    mkMountChangedCallback                  ,+    mountChangedCallbackWrapper             ,+    mountChangedClosure                     ,+    noMountChangedCallback                  ,+    onMountChanged                          ,+++-- ** PreUnmount+    MountPreUnmountCallback                 ,+    MountPreUnmountCallbackC                ,+    MountPreUnmountSignalInfo               ,+    afterMountPreUnmount                    ,+    mkMountPreUnmountCallback               ,+    mountPreUnmountCallbackWrapper          ,+    mountPreUnmountClosure                  ,+    noMountPreUnmountCallback               ,+    onMountPreUnmount                       ,+++-- ** Unmounted+    MountUnmountedCallback                  ,+    MountUnmountedCallbackC                 ,+    MountUnmountedSignalInfo                ,+    afterMountUnmounted                     ,+    mkMountUnmountedCallback                ,+    mountUnmountedCallbackWrapper           ,+    mountUnmountedClosure                   ,+    noMountUnmountedCallback                ,+    onMountUnmounted                        ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++-- interface Mount ++newtype Mount = Mount (ForeignPtr Mount)+noMount :: Maybe Mount+noMount = Nothing++-- signal Mount::changed+type MountChangedCallback =+    IO ()++noMountChangedCallback :: Maybe MountChangedCallback+noMountChangedCallback = Nothing++type MountChangedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkMountChangedCallback :: MountChangedCallbackC -> IO (FunPtr MountChangedCallbackC)++mountChangedClosure :: MountChangedCallback -> IO Closure+mountChangedClosure cb = newCClosure =<< mkMountChangedCallback wrapped+    where wrapped = mountChangedCallbackWrapper cb++mountChangedCallbackWrapper ::+    MountChangedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+mountChangedCallbackWrapper _cb _ _ = do+    _cb ++onMountChanged :: (GObject a, MonadIO m) => a -> MountChangedCallback -> m SignalHandlerId+onMountChanged obj cb = liftIO $ connectMountChanged obj cb SignalConnectBefore+afterMountChanged :: (GObject a, MonadIO m) => a -> MountChangedCallback -> m SignalHandlerId+afterMountChanged obj cb = connectMountChanged obj cb SignalConnectAfter++connectMountChanged :: (GObject a, MonadIO m) =>+                       a -> MountChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectMountChanged obj cb after = liftIO $ do+    cb' <- mkMountChangedCallback (mountChangedCallbackWrapper cb)+    connectSignalFunPtr obj "changed" cb' after++-- signal Mount::pre-unmount+type MountPreUnmountCallback =+    IO ()++noMountPreUnmountCallback :: Maybe MountPreUnmountCallback+noMountPreUnmountCallback = Nothing++type MountPreUnmountCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkMountPreUnmountCallback :: MountPreUnmountCallbackC -> IO (FunPtr MountPreUnmountCallbackC)++mountPreUnmountClosure :: MountPreUnmountCallback -> IO Closure+mountPreUnmountClosure cb = newCClosure =<< mkMountPreUnmountCallback wrapped+    where wrapped = mountPreUnmountCallbackWrapper cb++mountPreUnmountCallbackWrapper ::+    MountPreUnmountCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+mountPreUnmountCallbackWrapper _cb _ _ = do+    _cb ++onMountPreUnmount :: (GObject a, MonadIO m) => a -> MountPreUnmountCallback -> m SignalHandlerId+onMountPreUnmount obj cb = liftIO $ connectMountPreUnmount obj cb SignalConnectBefore+afterMountPreUnmount :: (GObject a, MonadIO m) => a -> MountPreUnmountCallback -> m SignalHandlerId+afterMountPreUnmount obj cb = connectMountPreUnmount obj cb SignalConnectAfter++connectMountPreUnmount :: (GObject a, MonadIO m) =>+                          a -> MountPreUnmountCallback -> SignalConnectMode -> m SignalHandlerId+connectMountPreUnmount obj cb after = liftIO $ do+    cb' <- mkMountPreUnmountCallback (mountPreUnmountCallbackWrapper cb)+    connectSignalFunPtr obj "pre-unmount" cb' after++-- signal Mount::unmounted+type MountUnmountedCallback =+    IO ()++noMountUnmountedCallback :: Maybe MountUnmountedCallback+noMountUnmountedCallback = Nothing++type MountUnmountedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkMountUnmountedCallback :: MountUnmountedCallbackC -> IO (FunPtr MountUnmountedCallbackC)++mountUnmountedClosure :: MountUnmountedCallback -> IO Closure+mountUnmountedClosure cb = newCClosure =<< mkMountUnmountedCallback wrapped+    where wrapped = mountUnmountedCallbackWrapper cb++mountUnmountedCallbackWrapper ::+    MountUnmountedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+mountUnmountedCallbackWrapper _cb _ _ = do+    _cb ++onMountUnmounted :: (GObject a, MonadIO m) => a -> MountUnmountedCallback -> m SignalHandlerId+onMountUnmounted obj cb = liftIO $ connectMountUnmounted obj cb SignalConnectBefore+afterMountUnmounted :: (GObject a, MonadIO m) => a -> MountUnmountedCallback -> m SignalHandlerId+afterMountUnmounted obj cb = connectMountUnmounted obj cb SignalConnectAfter++connectMountUnmounted :: (GObject a, MonadIO m) =>+                         a -> MountUnmountedCallback -> SignalConnectMode -> m SignalHandlerId+connectMountUnmounted obj cb after = liftIO $ do+    cb' <- mkMountUnmountedCallback (mountUnmountedCallbackWrapper cb)+    connectSignalFunPtr obj "unmounted" cb' after++type instance AttributeList Mount = MountAttributeList+type MountAttributeList = ('[ ] :: [(Symbol, *)])++data MountChangedSignalInfo+instance SignalInfo MountChangedSignalInfo where+    type HaskellCallbackType MountChangedSignalInfo = MountChangedCallback+    connectSignal _ = connectMountChanged++data MountPreUnmountSignalInfo+instance SignalInfo MountPreUnmountSignalInfo where+    type HaskellCallbackType MountPreUnmountSignalInfo = MountPreUnmountCallback+    connectSignal _ = connectMountPreUnmount++data MountUnmountedSignalInfo+instance SignalInfo MountUnmountedSignalInfo where+    type HaskellCallbackType MountUnmountedSignalInfo = MountUnmountedCallback+    connectSignal _ = connectMountUnmounted++type instance SignalList Mount = MountSignalList+type MountSignalList = ('[ '("changed", MountChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("pre-unmount", MountPreUnmountSignalInfo), '("unmounted", MountUnmountedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "g_mount_get_type"+    c_g_mount_get_type :: IO GType++type instance ParentTypes Mount = MountParentTypes+type MountParentTypes = '[GObject.Object]++instance GObject Mount where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_mount_get_type+    ++class GObject o => MountK o+instance (GObject o, IsDescendantOf Mount o) => MountK o++toMount :: MountK o => o -> IO Mount+toMount = unsafeCastTo Mount++-- method Mount::can_eject+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_can_eject" g_mount_can_eject :: +    Ptr Mount ->                            -- _obj : TInterface "Gio" "Mount"+    IO CInt+++mountCanEject ::+    (MonadIO m, MountK a) =>+    a ->                                    -- _obj+    m Bool+mountCanEject _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_mount_can_eject _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Mount::can_unmount+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_can_unmount" g_mount_can_unmount :: +    Ptr Mount ->                            -- _obj : TInterface "Gio" "Mount"+    IO CInt+++mountCanUnmount ::+    (MonadIO m, MountK a) =>+    a ->                                    -- _obj+    m Bool+mountCanUnmount _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_mount_can_unmount _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Mount::eject+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountUnmountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountUnmountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_eject" g_mount_eject :: +    Ptr Mount ->                            -- _obj : TInterface "Gio" "Mount"+    CUInt ->                                -- flags : TInterface "Gio" "MountUnmountFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()++{-# DEPRECATED mountEject ["(Since version 2.22)","Use g_mount_eject_with_operation() instead."]#-}+mountEject ::+    (MonadIO m, MountK a, CancellableK b) =>+    a ->                                    -- _obj+    [MountUnmountFlags] ->                  -- flags+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+mountEject _obj flags cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_mount_eject _obj' flags' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method Mount::eject_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_mount_eject_finish" g_mount_eject_finish :: +    Ptr Mount ->                            -- _obj : TInterface "Gio" "Mount"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt++{-# DEPRECATED mountEjectFinish ["(Since version 2.22)","Use g_mount_eject_with_operation_finish() instead."]#-}+mountEjectFinish ::+    (MonadIO m, MountK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+mountEjectFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_mount_eject_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++-- method Mount::eject_with_operation+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountUnmountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mount_operation", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountUnmountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mount_operation", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_eject_with_operation" g_mount_eject_with_operation :: +    Ptr Mount ->                            -- _obj : TInterface "Gio" "Mount"+    CUInt ->                                -- flags : TInterface "Gio" "MountUnmountFlags"+    Ptr MountOperation ->                   -- mount_operation : TInterface "Gio" "MountOperation"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++mountEjectWithOperation ::+    (MonadIO m, MountK a, MountOperationK b, CancellableK c) =>+    a ->                                    -- _obj+    [MountUnmountFlags] ->                  -- flags+    Maybe (b) ->                            -- mount_operation+    Maybe (c) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+mountEjectWithOperation _obj flags mount_operation cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    maybeMount_operation <- case mount_operation of+        Nothing -> return nullPtr+        Just jMount_operation -> do+            let jMount_operation' = unsafeManagedPtrCastPtr jMount_operation+            return jMount_operation'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_mount_eject_with_operation _obj' flags' maybeMount_operation maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust mount_operation touchManagedPtr+    whenJust cancellable touchManagedPtr+    return ()++-- method Mount::eject_with_operation_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_mount_eject_with_operation_finish" g_mount_eject_with_operation_finish :: +    Ptr Mount ->                            -- _obj : TInterface "Gio" "Mount"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++mountEjectWithOperationFinish ::+    (MonadIO m, MountK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+mountEjectWithOperationFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_mount_eject_with_operation_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++-- method Mount::get_default_location+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "File"+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_get_default_location" g_mount_get_default_location :: +    Ptr Mount ->                            -- _obj : TInterface "Gio" "Mount"+    IO (Ptr File)+++mountGetDefaultLocation ::+    (MonadIO m, MountK a) =>+    a ->                                    -- _obj+    m File+mountGetDefaultLocation _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_mount_get_default_location _obj'+    checkUnexpectedReturnNULL "g_mount_get_default_location" result+    result' <- (wrapObject File) result+    touchManagedPtr _obj+    return result'++-- method Mount::get_drive+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Drive"+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_get_drive" g_mount_get_drive :: +    Ptr Mount ->                            -- _obj : TInterface "Gio" "Mount"+    IO (Ptr Drive)+++mountGetDrive ::+    (MonadIO m, MountK a) =>+    a ->                                    -- _obj+    m Drive+mountGetDrive _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_mount_get_drive _obj'+    checkUnexpectedReturnNULL "g_mount_get_drive" result+    result' <- (wrapObject Drive) result+    touchManagedPtr _obj+    return result'++-- method Mount::get_icon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Icon"+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_get_icon" g_mount_get_icon :: +    Ptr Mount ->                            -- _obj : TInterface "Gio" "Mount"+    IO (Ptr Icon)+++mountGetIcon ::+    (MonadIO m, MountK a) =>+    a ->                                    -- _obj+    m Icon+mountGetIcon _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_mount_get_icon _obj'+    checkUnexpectedReturnNULL "g_mount_get_icon" result+    result' <- (wrapObject Icon) result+    touchManagedPtr _obj+    return result'++-- method Mount::get_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_get_name" g_mount_get_name :: +    Ptr Mount ->                            -- _obj : TInterface "Gio" "Mount"+    IO CString+++mountGetName ::+    (MonadIO m, MountK a) =>+    a ->                                    -- _obj+    m T.Text+mountGetName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_mount_get_name _obj'+    checkUnexpectedReturnNULL "g_mount_get_name" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method Mount::get_root+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "File"+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_get_root" g_mount_get_root :: +    Ptr Mount ->                            -- _obj : TInterface "Gio" "Mount"+    IO (Ptr File)+++mountGetRoot ::+    (MonadIO m, MountK a) =>+    a ->                                    -- _obj+    m File+mountGetRoot _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_mount_get_root _obj'+    checkUnexpectedReturnNULL "g_mount_get_root" result+    result' <- (wrapObject File) result+    touchManagedPtr _obj+    return result'++-- method Mount::get_sort_key+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_get_sort_key" g_mount_get_sort_key :: +    Ptr Mount ->                            -- _obj : TInterface "Gio" "Mount"+    IO CString+++mountGetSortKey ::+    (MonadIO m, MountK a) =>+    a ->                                    -- _obj+    m T.Text+mountGetSortKey _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_mount_get_sort_key _obj'+    checkUnexpectedReturnNULL "g_mount_get_sort_key" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Mount::get_symbolic_icon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Icon"+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_get_symbolic_icon" g_mount_get_symbolic_icon :: +    Ptr Mount ->                            -- _obj : TInterface "Gio" "Mount"+    IO (Ptr Icon)+++mountGetSymbolicIcon ::+    (MonadIO m, MountK a) =>+    a ->                                    -- _obj+    m Icon+mountGetSymbolicIcon _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_mount_get_symbolic_icon _obj'+    checkUnexpectedReturnNULL "g_mount_get_symbolic_icon" result+    result' <- (wrapObject Icon) result+    touchManagedPtr _obj+    return result'++-- method Mount::get_uuid+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_get_uuid" g_mount_get_uuid :: +    Ptr Mount ->                            -- _obj : TInterface "Gio" "Mount"+    IO CString+++mountGetUuid ::+    (MonadIO m, MountK a) =>+    a ->                                    -- _obj+    m T.Text+mountGetUuid _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_mount_get_uuid _obj'+    checkUnexpectedReturnNULL "g_mount_get_uuid" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method Mount::get_volume+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Volume"+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_get_volume" g_mount_get_volume :: +    Ptr Mount ->                            -- _obj : TInterface "Gio" "Mount"+    IO (Ptr Volume)+++mountGetVolume ::+    (MonadIO m, MountK a) =>+    a ->                                    -- _obj+    m Volume+mountGetVolume _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_mount_get_volume _obj'+    checkUnexpectedReturnNULL "g_mount_get_volume" result+    result' <- (wrapObject Volume) result+    touchManagedPtr _obj+    return result'++-- method Mount::guess_content_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "force_rescan", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "force_rescan", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_guess_content_type" g_mount_guess_content_type :: +    Ptr Mount ->                            -- _obj : TInterface "Gio" "Mount"+    CInt ->                                 -- force_rescan : TBasicType TBoolean+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++mountGuessContentType ::+    (MonadIO m, MountK a, CancellableK b) =>+    a ->                                    -- _obj+    Bool ->                                 -- force_rescan+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+mountGuessContentType _obj force_rescan cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let force_rescan' = (fromIntegral . fromEnum) force_rescan+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_mount_guess_content_type _obj' force_rescan' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method Mount::guess_content_type_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : True+-- Skip return : False++foreign import ccall "g_mount_guess_content_type_finish" g_mount_guess_content_type_finish :: +    Ptr Mount ->                            -- _obj : TInterface "Gio" "Mount"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr CString)+++mountGuessContentTypeFinish ::+    (MonadIO m, MountK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m [T.Text]+mountGuessContentTypeFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        result <- propagateGError $ g_mount_guess_content_type_finish _obj' result_'+        checkUnexpectedReturnNULL "g_mount_guess_content_type_finish" result+        result' <- unpackZeroTerminatedUTF8CArray result+        mapZeroTerminatedCArray freeMem result+        freeMem result+        touchManagedPtr _obj+        touchManagedPtr result_+        return result'+     ) (do+        return ()+     )++-- method Mount::guess_content_type_sync+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "force_rescan", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "force_rescan", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : True+-- Skip return : False++foreign import ccall "g_mount_guess_content_type_sync" g_mount_guess_content_type_sync :: +    Ptr Mount ->                            -- _obj : TInterface "Gio" "Mount"+    CInt ->                                 -- force_rescan : TBasicType TBoolean+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr CString)+++mountGuessContentTypeSync ::+    (MonadIO m, MountK a, CancellableK b) =>+    a ->                                    -- _obj+    Bool ->                                 -- force_rescan+    Maybe (b) ->                            -- cancellable+    m [T.Text]+mountGuessContentTypeSync _obj force_rescan cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let force_rescan' = (fromIntegral . fromEnum) force_rescan+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_mount_guess_content_type_sync _obj' force_rescan' maybeCancellable+        checkUnexpectedReturnNULL "g_mount_guess_content_type_sync" result+        result' <- unpackZeroTerminatedUTF8CArray result+        mapZeroTerminatedCArray freeMem result+        freeMem result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )++-- method Mount::is_shadowed+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_is_shadowed" g_mount_is_shadowed :: +    Ptr Mount ->                            -- _obj : TInterface "Gio" "Mount"+    IO CInt+++mountIsShadowed ::+    (MonadIO m, MountK a) =>+    a ->                                    -- _obj+    m Bool+mountIsShadowed _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_mount_is_shadowed _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Mount::remount+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountMountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mount_operation", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountMountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mount_operation", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_remount" g_mount_remount :: +    Ptr Mount ->                            -- _obj : TInterface "Gio" "Mount"+    CUInt ->                                -- flags : TInterface "Gio" "MountMountFlags"+    Ptr MountOperation ->                   -- mount_operation : TInterface "Gio" "MountOperation"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++mountRemount ::+    (MonadIO m, MountK a, MountOperationK b, CancellableK c) =>+    a ->                                    -- _obj+    [MountMountFlags] ->                    -- flags+    Maybe (b) ->                            -- mount_operation+    Maybe (c) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+mountRemount _obj flags mount_operation cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    maybeMount_operation <- case mount_operation of+        Nothing -> return nullPtr+        Just jMount_operation -> do+            let jMount_operation' = unsafeManagedPtrCastPtr jMount_operation+            return jMount_operation'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_mount_remount _obj' flags' maybeMount_operation maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust mount_operation touchManagedPtr+    whenJust cancellable touchManagedPtr+    return ()++-- method Mount::remount_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_mount_remount_finish" g_mount_remount_finish :: +    Ptr Mount ->                            -- _obj : TInterface "Gio" "Mount"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++mountRemountFinish ::+    (MonadIO m, MountK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+mountRemountFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_mount_remount_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++-- method Mount::shadow+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_shadow" g_mount_shadow :: +    Ptr Mount ->                            -- _obj : TInterface "Gio" "Mount"+    IO ()+++mountShadow ::+    (MonadIO m, MountK a) =>+    a ->                                    -- _obj+    m ()+mountShadow _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_mount_shadow _obj'+    touchManagedPtr _obj+    return ()++-- method Mount::unmount+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountUnmountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountUnmountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_unmount" g_mount_unmount :: +    Ptr Mount ->                            -- _obj : TInterface "Gio" "Mount"+    CUInt ->                                -- flags : TInterface "Gio" "MountUnmountFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()++{-# DEPRECATED mountUnmount ["(Since version 2.22)","Use g_mount_unmount_with_operation() instead."]#-}+mountUnmount ::+    (MonadIO m, MountK a, CancellableK b) =>+    a ->                                    -- _obj+    [MountUnmountFlags] ->                  -- flags+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+mountUnmount _obj flags cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_mount_unmount _obj' flags' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method Mount::unmount_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_mount_unmount_finish" g_mount_unmount_finish :: +    Ptr Mount ->                            -- _obj : TInterface "Gio" "Mount"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt++{-# DEPRECATED mountUnmountFinish ["(Since version 2.22)","Use g_mount_unmount_with_operation_finish() instead."]#-}+mountUnmountFinish ::+    (MonadIO m, MountK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+mountUnmountFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_mount_unmount_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++-- method Mount::unmount_with_operation+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountUnmountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mount_operation", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountUnmountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mount_operation", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_unmount_with_operation" g_mount_unmount_with_operation :: +    Ptr Mount ->                            -- _obj : TInterface "Gio" "Mount"+    CUInt ->                                -- flags : TInterface "Gio" "MountUnmountFlags"+    Ptr MountOperation ->                   -- mount_operation : TInterface "Gio" "MountOperation"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++mountUnmountWithOperation ::+    (MonadIO m, MountK a, MountOperationK b, CancellableK c) =>+    a ->                                    -- _obj+    [MountUnmountFlags] ->                  -- flags+    Maybe (b) ->                            -- mount_operation+    Maybe (c) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+mountUnmountWithOperation _obj flags mount_operation cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    maybeMount_operation <- case mount_operation of+        Nothing -> return nullPtr+        Just jMount_operation -> do+            let jMount_operation' = unsafeManagedPtrCastPtr jMount_operation+            return jMount_operation'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_mount_unmount_with_operation _obj' flags' maybeMount_operation maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust mount_operation touchManagedPtr+    whenJust cancellable touchManagedPtr+    return ()++-- method Mount::unmount_with_operation_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_mount_unmount_with_operation_finish" g_mount_unmount_with_operation_finish :: +    Ptr Mount ->                            -- _obj : TInterface "Gio" "Mount"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++mountUnmountWithOperationFinish ::+    (MonadIO m, MountK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+mountUnmountWithOperationFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_mount_unmount_with_operation_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++-- method Mount::unshadow+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_unshadow" g_mount_unshadow :: +    Ptr Mount ->                            -- _obj : TInterface "Gio" "Mount"+    IO ()+++mountUnshadow ::+    (MonadIO m, MountK a) =>+    a ->                                    -- _obj+    m ()+mountUnshadow _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_mount_unshadow _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Interfaces/Mount.hs-boot view
@@ -0,0 +1,16 @@+module GI.Gio.Interfaces.Mount where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Mount = Mount (ForeignPtr Mount)+data MountChangedSignalInfo+data MountPreUnmountSignalInfo+data MountUnmountedSignalInfo+instance GObject Mount where+class GObject o => MountK o+instance (GObject o, IsDescendantOf Mount o) => MountK o
+ GI/Gio/Interfaces/NetworkMonitor.hs view
@@ -0,0 +1,417 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Interfaces.NetworkMonitor+    ( ++-- * Exported types+    NetworkMonitor(..)                      ,+    noNetworkMonitor                        ,+    NetworkMonitorK                         ,+    toNetworkMonitor                        ,+++ -- * Methods+-- ** networkMonitorCanReach+    networkMonitorCanReach                  ,+++-- ** networkMonitorCanReachAsync+    networkMonitorCanReachAsync             ,+++-- ** networkMonitorCanReachFinish+    networkMonitorCanReachFinish            ,+++-- ** networkMonitorGetConnectivity+    networkMonitorGetConnectivity           ,+++-- ** networkMonitorGetNetworkAvailable+    networkMonitorGetNetworkAvailable       ,+++-- ** networkMonitorGetNetworkMetered+    networkMonitorGetNetworkMetered         ,+++++ -- * Properties+-- ** Connectivity+    NetworkMonitorConnectivityPropertyInfo  ,+    getNetworkMonitorConnectivity           ,+++-- ** NetworkAvailable+    NetworkMonitorNetworkAvailablePropertyInfo,+    getNetworkMonitorNetworkAvailable       ,+++-- ** NetworkMetered+    NetworkMonitorNetworkMeteredPropertyInfo,+    getNetworkMonitorNetworkMetered         ,+++++ -- * Signals+-- ** NetworkChanged+    NetworkMonitorNetworkChangedCallback    ,+    NetworkMonitorNetworkChangedCallbackC   ,+    NetworkMonitorNetworkChangedSignalInfo  ,+    afterNetworkMonitorNetworkChanged       ,+    mkNetworkMonitorNetworkChangedCallback  ,+    networkMonitorNetworkChangedCallbackWrapper,+    networkMonitorNetworkChangedClosure     ,+    noNetworkMonitorNetworkChangedCallback  ,+    onNetworkMonitorNetworkChanged          ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++-- interface NetworkMonitor ++newtype NetworkMonitor = NetworkMonitor (ForeignPtr NetworkMonitor)+noNetworkMonitor :: Maybe NetworkMonitor+noNetworkMonitor = Nothing++-- signal NetworkMonitor::network-changed+type NetworkMonitorNetworkChangedCallback =+    Bool ->+    IO ()++noNetworkMonitorNetworkChangedCallback :: Maybe NetworkMonitorNetworkChangedCallback+noNetworkMonitorNetworkChangedCallback = Nothing++type NetworkMonitorNetworkChangedCallbackC =+    Ptr () ->                               -- object+    CInt ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkNetworkMonitorNetworkChangedCallback :: NetworkMonitorNetworkChangedCallbackC -> IO (FunPtr NetworkMonitorNetworkChangedCallbackC)++networkMonitorNetworkChangedClosure :: NetworkMonitorNetworkChangedCallback -> IO Closure+networkMonitorNetworkChangedClosure cb = newCClosure =<< mkNetworkMonitorNetworkChangedCallback wrapped+    where wrapped = networkMonitorNetworkChangedCallbackWrapper cb++networkMonitorNetworkChangedCallbackWrapper ::+    NetworkMonitorNetworkChangedCallback ->+    Ptr () ->+    CInt ->+    Ptr () ->+    IO ()+networkMonitorNetworkChangedCallbackWrapper _cb _ available _ = do+    let available' = (/= 0) available+    _cb  available'++onNetworkMonitorNetworkChanged :: (GObject a, MonadIO m) => a -> NetworkMonitorNetworkChangedCallback -> m SignalHandlerId+onNetworkMonitorNetworkChanged obj cb = liftIO $ connectNetworkMonitorNetworkChanged obj cb SignalConnectBefore+afterNetworkMonitorNetworkChanged :: (GObject a, MonadIO m) => a -> NetworkMonitorNetworkChangedCallback -> m SignalHandlerId+afterNetworkMonitorNetworkChanged obj cb = connectNetworkMonitorNetworkChanged obj cb SignalConnectAfter++connectNetworkMonitorNetworkChanged :: (GObject a, MonadIO m) =>+                                       a -> NetworkMonitorNetworkChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectNetworkMonitorNetworkChanged obj cb after = liftIO $ do+    cb' <- mkNetworkMonitorNetworkChangedCallback (networkMonitorNetworkChangedCallbackWrapper cb)+    connectSignalFunPtr obj "network-changed" cb' after++-- VVV Prop "connectivity"+   -- Type: TInterface "Gio" "NetworkConnectivity"+   -- Flags: [PropertyReadable]++getNetworkMonitorConnectivity :: (MonadIO m, NetworkMonitorK o) => o -> m NetworkConnectivity+getNetworkMonitorConnectivity obj = liftIO $ getObjectPropertyEnum obj "connectivity"++data NetworkMonitorConnectivityPropertyInfo+instance AttrInfo NetworkMonitorConnectivityPropertyInfo where+    type AttrAllowedOps NetworkMonitorConnectivityPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint NetworkMonitorConnectivityPropertyInfo = (~) ()+    type AttrBaseTypeConstraint NetworkMonitorConnectivityPropertyInfo = NetworkMonitorK+    type AttrGetType NetworkMonitorConnectivityPropertyInfo = NetworkConnectivity+    type AttrLabel NetworkMonitorConnectivityPropertyInfo = "NetworkMonitor::connectivity"+    attrGet _ = getNetworkMonitorConnectivity+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "network-available"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getNetworkMonitorNetworkAvailable :: (MonadIO m, NetworkMonitorK o) => o -> m Bool+getNetworkMonitorNetworkAvailable obj = liftIO $ getObjectPropertyBool obj "network-available"++data NetworkMonitorNetworkAvailablePropertyInfo+instance AttrInfo NetworkMonitorNetworkAvailablePropertyInfo where+    type AttrAllowedOps NetworkMonitorNetworkAvailablePropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint NetworkMonitorNetworkAvailablePropertyInfo = (~) ()+    type AttrBaseTypeConstraint NetworkMonitorNetworkAvailablePropertyInfo = NetworkMonitorK+    type AttrGetType NetworkMonitorNetworkAvailablePropertyInfo = Bool+    type AttrLabel NetworkMonitorNetworkAvailablePropertyInfo = "NetworkMonitor::network-available"+    attrGet _ = getNetworkMonitorNetworkAvailable+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "network-metered"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getNetworkMonitorNetworkMetered :: (MonadIO m, NetworkMonitorK o) => o -> m Bool+getNetworkMonitorNetworkMetered obj = liftIO $ getObjectPropertyBool obj "network-metered"++data NetworkMonitorNetworkMeteredPropertyInfo+instance AttrInfo NetworkMonitorNetworkMeteredPropertyInfo where+    type AttrAllowedOps NetworkMonitorNetworkMeteredPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint NetworkMonitorNetworkMeteredPropertyInfo = (~) ()+    type AttrBaseTypeConstraint NetworkMonitorNetworkMeteredPropertyInfo = NetworkMonitorK+    type AttrGetType NetworkMonitorNetworkMeteredPropertyInfo = Bool+    type AttrLabel NetworkMonitorNetworkMeteredPropertyInfo = "NetworkMonitor::network-metered"+    attrGet _ = getNetworkMonitorNetworkMetered+    attrSet _ = undefined+    attrConstruct _ = undefined++type instance AttributeList NetworkMonitor = NetworkMonitorAttributeList+type NetworkMonitorAttributeList = ('[ '("connectivity", NetworkMonitorConnectivityPropertyInfo), '("network-available", NetworkMonitorNetworkAvailablePropertyInfo), '("network-metered", NetworkMonitorNetworkMeteredPropertyInfo)] :: [(Symbol, *)])++data NetworkMonitorNetworkChangedSignalInfo+instance SignalInfo NetworkMonitorNetworkChangedSignalInfo where+    type HaskellCallbackType NetworkMonitorNetworkChangedSignalInfo = NetworkMonitorNetworkChangedCallback+    connectSignal _ = connectNetworkMonitorNetworkChanged++type instance SignalList NetworkMonitor = NetworkMonitorSignalList+type NetworkMonitorSignalList = ('[ '("network-changed", NetworkMonitorNetworkChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "g_network_monitor_get_type"+    c_g_network_monitor_get_type :: IO GType++type instance ParentTypes NetworkMonitor = NetworkMonitorParentTypes+type NetworkMonitorParentTypes = '[Initable, GObject.Object]++instance GObject NetworkMonitor where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_network_monitor_get_type+    ++class GObject o => NetworkMonitorK o+instance (GObject o, IsDescendantOf NetworkMonitor o) => NetworkMonitorK o++toNetworkMonitor :: NetworkMonitorK o => o -> IO NetworkMonitor+toNetworkMonitor = unsafeCastTo NetworkMonitor++-- method NetworkMonitor::can_reach+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "NetworkMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "connectable", argType = TInterface "Gio" "SocketConnectable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "NetworkMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "connectable", argType = TInterface "Gio" "SocketConnectable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_network_monitor_can_reach" g_network_monitor_can_reach :: +    Ptr NetworkMonitor ->                   -- _obj : TInterface "Gio" "NetworkMonitor"+    Ptr SocketConnectable ->                -- connectable : TInterface "Gio" "SocketConnectable"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++networkMonitorCanReach ::+    (MonadIO m, NetworkMonitorK a, SocketConnectableK b, CancellableK c) =>+    a ->                                    -- _obj+    b ->                                    -- connectable+    Maybe (c) ->                            -- cancellable+    m ()+networkMonitorCanReach _obj connectable cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let connectable' = unsafeManagedPtrCastPtr connectable+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_network_monitor_can_reach _obj' connectable' maybeCancellable+        touchManagedPtr _obj+        touchManagedPtr connectable+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method NetworkMonitor::can_reach_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "NetworkMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "connectable", argType = TInterface "Gio" "SocketConnectable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "NetworkMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "connectable", argType = TInterface "Gio" "SocketConnectable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_network_monitor_can_reach_async" g_network_monitor_can_reach_async :: +    Ptr NetworkMonitor ->                   -- _obj : TInterface "Gio" "NetworkMonitor"+    Ptr SocketConnectable ->                -- connectable : TInterface "Gio" "SocketConnectable"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++networkMonitorCanReachAsync ::+    (MonadIO m, NetworkMonitorK a, SocketConnectableK b, CancellableK c) =>+    a ->                                    -- _obj+    b ->                                    -- connectable+    Maybe (c) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+networkMonitorCanReachAsync _obj connectable cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let connectable' = unsafeManagedPtrCastPtr connectable+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_network_monitor_can_reach_async _obj' connectable' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    touchManagedPtr connectable+    whenJust cancellable touchManagedPtr+    return ()++-- method NetworkMonitor::can_reach_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "NetworkMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "NetworkMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_network_monitor_can_reach_finish" g_network_monitor_can_reach_finish :: +    Ptr NetworkMonitor ->                   -- _obj : TInterface "Gio" "NetworkMonitor"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++networkMonitorCanReachFinish ::+    (MonadIO m, NetworkMonitorK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+networkMonitorCanReachFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_network_monitor_can_reach_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++-- method NetworkMonitor::get_connectivity+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "NetworkMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "NetworkMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "NetworkConnectivity"+-- throws : False+-- Skip return : False++foreign import ccall "g_network_monitor_get_connectivity" g_network_monitor_get_connectivity :: +    Ptr NetworkMonitor ->                   -- _obj : TInterface "Gio" "NetworkMonitor"+    IO CUInt+++networkMonitorGetConnectivity ::+    (MonadIO m, NetworkMonitorK a) =>+    a ->                                    -- _obj+    m NetworkConnectivity+networkMonitorGetConnectivity _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_network_monitor_get_connectivity _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method NetworkMonitor::get_network_available+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "NetworkMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "NetworkMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_network_monitor_get_network_available" g_network_monitor_get_network_available :: +    Ptr NetworkMonitor ->                   -- _obj : TInterface "Gio" "NetworkMonitor"+    IO CInt+++networkMonitorGetNetworkAvailable ::+    (MonadIO m, NetworkMonitorK a) =>+    a ->                                    -- _obj+    m Bool+networkMonitorGetNetworkAvailable _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_network_monitor_get_network_available _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method NetworkMonitor::get_network_metered+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "NetworkMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "NetworkMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_network_monitor_get_network_metered" g_network_monitor_get_network_metered :: +    Ptr NetworkMonitor ->                   -- _obj : TInterface "Gio" "NetworkMonitor"+    IO CInt+++networkMonitorGetNetworkMetered ::+    (MonadIO m, NetworkMonitorK a) =>+    a ->                                    -- _obj+    m Bool+networkMonitorGetNetworkMetered _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_network_monitor_get_network_metered _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++
+ GI/Gio/Interfaces/NetworkMonitor.hs-boot view
@@ -0,0 +1,17 @@+module GI.Gio.Interfaces.NetworkMonitor where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype NetworkMonitor = NetworkMonitor (ForeignPtr NetworkMonitor)+data NetworkMonitorConnectivityPropertyInfo+data NetworkMonitorNetworkAvailablePropertyInfo+data NetworkMonitorNetworkMeteredPropertyInfo+data NetworkMonitorNetworkChangedSignalInfo+instance GObject NetworkMonitor where+class GObject o => NetworkMonitorK o+instance (GObject o, IsDescendantOf NetworkMonitor o) => NetworkMonitorK o
+ GI/Gio/Interfaces/PollableInputStream.hs view
@@ -0,0 +1,207 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Interfaces.PollableInputStream+    ( ++-- * Exported types+    PollableInputStream(..)                 ,+    noPollableInputStream                   ,+    PollableInputStreamK                    ,+    toPollableInputStream                   ,+++ -- * Methods+-- ** pollableInputStreamCanPoll+    pollableInputStreamCanPoll              ,+++-- ** pollableInputStreamCreateSource+    pollableInputStreamCreateSource         ,+++-- ** pollableInputStreamIsReadable+    pollableInputStreamIsReadable           ,+++-- ** pollableInputStreamReadNonblocking+    pollableInputStreamReadNonblocking      ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++-- interface PollableInputStream ++newtype PollableInputStream = PollableInputStream (ForeignPtr PollableInputStream)+noPollableInputStream :: Maybe PollableInputStream+noPollableInputStream = Nothing++type instance AttributeList PollableInputStream = PollableInputStreamAttributeList+type PollableInputStreamAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList PollableInputStream = PollableInputStreamSignalList+type PollableInputStreamSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "g_pollable_input_stream_get_type"+    c_g_pollable_input_stream_get_type :: IO GType++type instance ParentTypes PollableInputStream = PollableInputStreamParentTypes+type PollableInputStreamParentTypes = '[InputStream, GObject.Object]++instance GObject PollableInputStream where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_pollable_input_stream_get_type+    ++class GObject o => PollableInputStreamK o+instance (GObject o, IsDescendantOf PollableInputStream o) => PollableInputStreamK o++toPollableInputStream :: PollableInputStreamK o => o -> IO PollableInputStream+toPollableInputStream = unsafeCastTo PollableInputStream++-- method PollableInputStream::can_poll+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "PollableInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "PollableInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_pollable_input_stream_can_poll" g_pollable_input_stream_can_poll :: +    Ptr PollableInputStream ->              -- _obj : TInterface "Gio" "PollableInputStream"+    IO CInt+++pollableInputStreamCanPoll ::+    (MonadIO m, PollableInputStreamK a) =>+    a ->                                    -- _obj+    m Bool+pollableInputStreamCanPoll _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_pollable_input_stream_can_poll _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method PollableInputStream::create_source+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "PollableInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "PollableInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GLib" "Source"+-- throws : False+-- Skip return : False++foreign import ccall "g_pollable_input_stream_create_source" g_pollable_input_stream_create_source :: +    Ptr PollableInputStream ->              -- _obj : TInterface "Gio" "PollableInputStream"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    IO (Ptr GLib.Source)+++pollableInputStreamCreateSource ::+    (MonadIO m, PollableInputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m GLib.Source+pollableInputStreamCreateSource _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    result <- g_pollable_input_stream_create_source _obj' maybeCancellable+    checkUnexpectedReturnNULL "g_pollable_input_stream_create_source" result+    result' <- (wrapBoxed GLib.Source) result+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return result'++-- method PollableInputStream::is_readable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "PollableInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "PollableInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_pollable_input_stream_is_readable" g_pollable_input_stream_is_readable :: +    Ptr PollableInputStream ->              -- _obj : TInterface "Gio" "PollableInputStream"+    IO CInt+++pollableInputStreamIsReadable ::+    (MonadIO m, PollableInputStreamK a) =>+    a ->                                    -- _obj+    m Bool+pollableInputStreamIsReadable _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_pollable_input_stream_is_readable _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method PollableInputStream::read_nonblocking+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "PollableInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "PollableInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : True+-- Skip return : False++foreign import ccall "g_pollable_input_stream_read_nonblocking" g_pollable_input_stream_read_nonblocking :: +    Ptr PollableInputStream ->              -- _obj : TInterface "Gio" "PollableInputStream"+    Ptr Word8 ->                            -- buffer : TCArray False (-1) 2 (TBasicType TUInt8)+    Word64 ->                               -- count : TBasicType TUInt64+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO Int64+++pollableInputStreamReadNonblocking ::+    (MonadIO m, PollableInputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    ByteString ->                           -- buffer+    Maybe (b) ->                            -- cancellable+    m Int64+pollableInputStreamReadNonblocking _obj buffer cancellable = liftIO $ do+    let count = fromIntegral $ B.length buffer+    let _obj' = unsafeManagedPtrCastPtr _obj+    buffer' <- packByteString buffer+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_pollable_input_stream_read_nonblocking _obj' buffer' count maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem buffer'+        return result+     ) (do+        freeMem buffer'+     )++
+ GI/Gio/Interfaces/PollableInputStream.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Interfaces.PollableInputStream where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype PollableInputStream = PollableInputStream (ForeignPtr PollableInputStream)+instance GObject PollableInputStream where+class GObject o => PollableInputStreamK o+instance (GObject o, IsDescendantOf PollableInputStream o) => PollableInputStreamK o
+ GI/Gio/Interfaces/PollableOutputStream.hs view
@@ -0,0 +1,207 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Interfaces.PollableOutputStream+    ( ++-- * Exported types+    PollableOutputStream(..)                ,+    noPollableOutputStream                  ,+    PollableOutputStreamK                   ,+    toPollableOutputStream                  ,+++ -- * Methods+-- ** pollableOutputStreamCanPoll+    pollableOutputStreamCanPoll             ,+++-- ** pollableOutputStreamCreateSource+    pollableOutputStreamCreateSource        ,+++-- ** pollableOutputStreamIsWritable+    pollableOutputStreamIsWritable          ,+++-- ** pollableOutputStreamWriteNonblocking+    pollableOutputStreamWriteNonblocking    ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++-- interface PollableOutputStream ++newtype PollableOutputStream = PollableOutputStream (ForeignPtr PollableOutputStream)+noPollableOutputStream :: Maybe PollableOutputStream+noPollableOutputStream = Nothing++type instance AttributeList PollableOutputStream = PollableOutputStreamAttributeList+type PollableOutputStreamAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList PollableOutputStream = PollableOutputStreamSignalList+type PollableOutputStreamSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "g_pollable_output_stream_get_type"+    c_g_pollable_output_stream_get_type :: IO GType++type instance ParentTypes PollableOutputStream = PollableOutputStreamParentTypes+type PollableOutputStreamParentTypes = '[OutputStream, GObject.Object]++instance GObject PollableOutputStream where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_pollable_output_stream_get_type+    ++class GObject o => PollableOutputStreamK o+instance (GObject o, IsDescendantOf PollableOutputStream o) => PollableOutputStreamK o++toPollableOutputStream :: PollableOutputStreamK o => o -> IO PollableOutputStream+toPollableOutputStream = unsafeCastTo PollableOutputStream++-- method PollableOutputStream::can_poll+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "PollableOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "PollableOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_pollable_output_stream_can_poll" g_pollable_output_stream_can_poll :: +    Ptr PollableOutputStream ->             -- _obj : TInterface "Gio" "PollableOutputStream"+    IO CInt+++pollableOutputStreamCanPoll ::+    (MonadIO m, PollableOutputStreamK a) =>+    a ->                                    -- _obj+    m Bool+pollableOutputStreamCanPoll _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_pollable_output_stream_can_poll _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method PollableOutputStream::create_source+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "PollableOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "PollableOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GLib" "Source"+-- throws : False+-- Skip return : False++foreign import ccall "g_pollable_output_stream_create_source" g_pollable_output_stream_create_source :: +    Ptr PollableOutputStream ->             -- _obj : TInterface "Gio" "PollableOutputStream"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    IO (Ptr GLib.Source)+++pollableOutputStreamCreateSource ::+    (MonadIO m, PollableOutputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m GLib.Source+pollableOutputStreamCreateSource _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    result <- g_pollable_output_stream_create_source _obj' maybeCancellable+    checkUnexpectedReturnNULL "g_pollable_output_stream_create_source" result+    result' <- (wrapBoxed GLib.Source) result+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return result'++-- method PollableOutputStream::is_writable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "PollableOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "PollableOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_pollable_output_stream_is_writable" g_pollable_output_stream_is_writable :: +    Ptr PollableOutputStream ->             -- _obj : TInterface "Gio" "PollableOutputStream"+    IO CInt+++pollableOutputStreamIsWritable ::+    (MonadIO m, PollableOutputStreamK a) =>+    a ->                                    -- _obj+    m Bool+pollableOutputStreamIsWritable _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_pollable_output_stream_is_writable _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method PollableOutputStream::write_nonblocking+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "PollableOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "PollableOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : True+-- Skip return : False++foreign import ccall "g_pollable_output_stream_write_nonblocking" g_pollable_output_stream_write_nonblocking :: +    Ptr PollableOutputStream ->             -- _obj : TInterface "Gio" "PollableOutputStream"+    Ptr Word8 ->                            -- buffer : TCArray False (-1) 2 (TBasicType TUInt8)+    Word64 ->                               -- count : TBasicType TUInt64+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO Int64+++pollableOutputStreamWriteNonblocking ::+    (MonadIO m, PollableOutputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    ByteString ->                           -- buffer+    Maybe (b) ->                            -- cancellable+    m Int64+pollableOutputStreamWriteNonblocking _obj buffer cancellable = liftIO $ do+    let count = fromIntegral $ B.length buffer+    let _obj' = unsafeManagedPtrCastPtr _obj+    buffer' <- packByteString buffer+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_pollable_output_stream_write_nonblocking _obj' buffer' count maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem buffer'+        return result+     ) (do+        freeMem buffer'+     )++
+ GI/Gio/Interfaces/PollableOutputStream.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Interfaces.PollableOutputStream where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype PollableOutputStream = PollableOutputStream (ForeignPtr PollableOutputStream)+instance GObject PollableOutputStream where+class GObject o => PollableOutputStreamK o+instance (GObject o, IsDescendantOf PollableOutputStream o) => PollableOutputStreamK o
+ GI/Gio/Interfaces/Proxy.hs view
@@ -0,0 +1,237 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Interfaces.Proxy+    ( ++-- * Exported types+    Proxy(..)                               ,+    noProxy                                 ,+    ProxyK                                  ,+    toProxy                                 ,+++ -- * Methods+-- ** proxyConnect+    proxyConnect                            ,+++-- ** proxyConnectAsync+    proxyConnectAsync                       ,+++-- ** proxyConnectFinish+    proxyConnectFinish                      ,+++-- ** proxySupportsHostname+    proxySupportsHostname                   ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++-- interface Proxy ++newtype Proxy = Proxy (ForeignPtr Proxy)+noProxy :: Maybe Proxy+noProxy = Nothing++type instance AttributeList Proxy = ProxyAttributeList+type ProxyAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList Proxy = ProxySignalList+type ProxySignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "g_proxy_get_type"+    c_g_proxy_get_type :: IO GType++type instance ParentTypes Proxy = ProxyParentTypes+type ProxyParentTypes = '[GObject.Object]++instance GObject Proxy where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_proxy_get_type+    ++class GObject o => ProxyK o+instance (GObject o, IsDescendantOf Proxy o) => ProxyK o++toProxy :: ProxyK o => o -> IO Proxy+toProxy = unsafeCastTo Proxy++-- method Proxy::connect+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Proxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "connection", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "proxy_address", argType = TInterface "Gio" "ProxyAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Proxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "connection", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "proxy_address", argType = TInterface "Gio" "ProxyAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "IOStream"+-- throws : True+-- Skip return : False++foreign import ccall "g_proxy_connect" g_proxy_connect :: +    Ptr Proxy ->                            -- _obj : TInterface "Gio" "Proxy"+    Ptr IOStream ->                         -- connection : TInterface "Gio" "IOStream"+    Ptr ProxyAddress ->                     -- proxy_address : TInterface "Gio" "ProxyAddress"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr IOStream)+++proxyConnect ::+    (MonadIO m, ProxyK a, IOStreamK b, ProxyAddressK c, CancellableK d) =>+    a ->                                    -- _obj+    b ->                                    -- connection+    c ->                                    -- proxy_address+    Maybe (d) ->                            -- cancellable+    m IOStream+proxyConnect _obj connection proxy_address cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let connection' = unsafeManagedPtrCastPtr connection+    let proxy_address' = unsafeManagedPtrCastPtr proxy_address+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_proxy_connect _obj' connection' proxy_address' maybeCancellable+        checkUnexpectedReturnNULL "g_proxy_connect" result+        result' <- (wrapObject IOStream) result+        touchManagedPtr _obj+        touchManagedPtr connection+        touchManagedPtr proxy_address+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )++-- method Proxy::connect_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Proxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "connection", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "proxy_address", argType = TInterface "Gio" "ProxyAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Proxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "connection", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "proxy_address", argType = TInterface "Gio" "ProxyAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_proxy_connect_async" g_proxy_connect_async :: +    Ptr Proxy ->                            -- _obj : TInterface "Gio" "Proxy"+    Ptr IOStream ->                         -- connection : TInterface "Gio" "IOStream"+    Ptr ProxyAddress ->                     -- proxy_address : TInterface "Gio" "ProxyAddress"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++proxyConnectAsync ::+    (MonadIO m, ProxyK a, IOStreamK b, ProxyAddressK c, CancellableK d) =>+    a ->                                    -- _obj+    b ->                                    -- connection+    c ->                                    -- proxy_address+    Maybe (d) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+proxyConnectAsync _obj connection proxy_address cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let connection' = unsafeManagedPtrCastPtr connection+    let proxy_address' = unsafeManagedPtrCastPtr proxy_address+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_proxy_connect_async _obj' connection' proxy_address' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    touchManagedPtr connection+    touchManagedPtr proxy_address+    whenJust cancellable touchManagedPtr+    return ()++-- method Proxy::connect_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Proxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Proxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "IOStream"+-- throws : True+-- Skip return : False++foreign import ccall "g_proxy_connect_finish" g_proxy_connect_finish :: +    Ptr Proxy ->                            -- _obj : TInterface "Gio" "Proxy"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr IOStream)+++proxyConnectFinish ::+    (MonadIO m, ProxyK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m IOStream+proxyConnectFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        result <- propagateGError $ g_proxy_connect_finish _obj' result_'+        checkUnexpectedReturnNULL "g_proxy_connect_finish" result+        result' <- (wrapObject IOStream) result+        touchManagedPtr _obj+        touchManagedPtr result_+        return result'+     ) (do+        return ()+     )++-- method Proxy::supports_hostname+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Proxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Proxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_proxy_supports_hostname" g_proxy_supports_hostname :: +    Ptr Proxy ->                            -- _obj : TInterface "Gio" "Proxy"+    IO CInt+++proxySupportsHostname ::+    (MonadIO m, ProxyK a) =>+    a ->                                    -- _obj+    m Bool+proxySupportsHostname _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_proxy_supports_hostname _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++
+ GI/Gio/Interfaces/Proxy.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Interfaces.Proxy where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Proxy = Proxy (ForeignPtr Proxy)+instance GObject Proxy where+class GObject o => ProxyK o+instance (GObject o, IsDescendantOf Proxy o) => ProxyK o
+ GI/Gio/Interfaces/ProxyResolver.hs view
@@ -0,0 +1,233 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Interfaces.ProxyResolver+    ( ++-- * Exported types+    ProxyResolver(..)                       ,+    noProxyResolver                         ,+    ProxyResolverK                          ,+    toProxyResolver                         ,+++ -- * Methods+-- ** proxyResolverIsSupported+    proxyResolverIsSupported                ,+++-- ** proxyResolverLookup+    proxyResolverLookup                     ,+++-- ** proxyResolverLookupAsync+    proxyResolverLookupAsync                ,+++-- ** proxyResolverLookupFinish+    proxyResolverLookupFinish               ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++-- interface ProxyResolver ++newtype ProxyResolver = ProxyResolver (ForeignPtr ProxyResolver)+noProxyResolver :: Maybe ProxyResolver+noProxyResolver = Nothing++type instance AttributeList ProxyResolver = ProxyResolverAttributeList+type ProxyResolverAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList ProxyResolver = ProxyResolverSignalList+type ProxyResolverSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "g_proxy_resolver_get_type"+    c_g_proxy_resolver_get_type :: IO GType++type instance ParentTypes ProxyResolver = ProxyResolverParentTypes+type ProxyResolverParentTypes = '[GObject.Object]++instance GObject ProxyResolver where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_proxy_resolver_get_type+    ++class GObject o => ProxyResolverK o+instance (GObject o, IsDescendantOf ProxyResolver o) => ProxyResolverK o++toProxyResolver :: ProxyResolverK o => o -> IO ProxyResolver+toProxyResolver = unsafeCastTo ProxyResolver++-- method ProxyResolver::is_supported+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ProxyResolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ProxyResolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_proxy_resolver_is_supported" g_proxy_resolver_is_supported :: +    Ptr ProxyResolver ->                    -- _obj : TInterface "Gio" "ProxyResolver"+    IO CInt+++proxyResolverIsSupported ::+    (MonadIO m, ProxyResolverK a) =>+    a ->                                    -- _obj+    m Bool+proxyResolverIsSupported _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_proxy_resolver_is_supported _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method ProxyResolver::lookup+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ProxyResolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ProxyResolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : True+-- Skip return : False++foreign import ccall "g_proxy_resolver_lookup" g_proxy_resolver_lookup :: +    Ptr ProxyResolver ->                    -- _obj : TInterface "Gio" "ProxyResolver"+    CString ->                              -- uri : TBasicType TUTF8+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr CString)+++proxyResolverLookup ::+    (MonadIO m, ProxyResolverK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- uri+    Maybe (b) ->                            -- cancellable+    m [T.Text]+proxyResolverLookup _obj uri cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    uri' <- textToCString uri+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_proxy_resolver_lookup _obj' uri' maybeCancellable+        checkUnexpectedReturnNULL "g_proxy_resolver_lookup" result+        result' <- unpackZeroTerminatedUTF8CArray result+        mapZeroTerminatedCArray freeMem result+        freeMem result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem uri'+        return result'+     ) (do+        freeMem uri'+     )++-- method ProxyResolver::lookup_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ProxyResolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ProxyResolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_proxy_resolver_lookup_async" g_proxy_resolver_lookup_async :: +    Ptr ProxyResolver ->                    -- _obj : TInterface "Gio" "ProxyResolver"+    CString ->                              -- uri : TBasicType TUTF8+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++proxyResolverLookupAsync ::+    (MonadIO m, ProxyResolverK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- uri+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+proxyResolverLookupAsync _obj uri cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    uri' <- textToCString uri+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_proxy_resolver_lookup_async _obj' uri' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    freeMem uri'+    return ()++-- method ProxyResolver::lookup_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ProxyResolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ProxyResolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : True+-- Skip return : False++foreign import ccall "g_proxy_resolver_lookup_finish" g_proxy_resolver_lookup_finish :: +    Ptr ProxyResolver ->                    -- _obj : TInterface "Gio" "ProxyResolver"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr CString)+++proxyResolverLookupFinish ::+    (MonadIO m, ProxyResolverK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m [T.Text]+proxyResolverLookupFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        result <- propagateGError $ g_proxy_resolver_lookup_finish _obj' result_'+        checkUnexpectedReturnNULL "g_proxy_resolver_lookup_finish" result+        result' <- unpackZeroTerminatedUTF8CArray result+        mapZeroTerminatedCArray freeMem result+        freeMem result+        touchManagedPtr _obj+        touchManagedPtr result_+        return result'+     ) (do+        return ()+     )++
+ GI/Gio/Interfaces/ProxyResolver.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Interfaces.ProxyResolver where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype ProxyResolver = ProxyResolver (ForeignPtr ProxyResolver)+instance GObject ProxyResolver where+class GObject o => ProxyResolverK o+instance (GObject o, IsDescendantOf ProxyResolver o) => ProxyResolverK o
+ GI/Gio/Interfaces/RemoteActionGroup.hs view
@@ -0,0 +1,143 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Interfaces.RemoteActionGroup+    ( ++-- * Exported types+    RemoteActionGroup(..)                   ,+    noRemoteActionGroup                     ,+    RemoteActionGroupK                      ,+    toRemoteActionGroup                     ,+++ -- * Methods+-- ** remoteActionGroupActivateActionFull+    remoteActionGroupActivateActionFull     ,+++-- ** remoteActionGroupChangeActionStateFull+    remoteActionGroupChangeActionStateFull  ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++-- interface RemoteActionGroup ++newtype RemoteActionGroup = RemoteActionGroup (ForeignPtr RemoteActionGroup)+noRemoteActionGroup :: Maybe RemoteActionGroup+noRemoteActionGroup = Nothing++type instance AttributeList RemoteActionGroup = RemoteActionGroupAttributeList+type RemoteActionGroupAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList RemoteActionGroup = RemoteActionGroupSignalList+type RemoteActionGroupSignalList = ('[ '("action-added", ActionGroupActionAddedSignalInfo), '("action-enabled-changed", ActionGroupActionEnabledChangedSignalInfo), '("action-removed", ActionGroupActionRemovedSignalInfo), '("action-state-changed", ActionGroupActionStateChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "g_remote_action_group_get_type"+    c_g_remote_action_group_get_type :: IO GType++type instance ParentTypes RemoteActionGroup = RemoteActionGroupParentTypes+type RemoteActionGroupParentTypes = '[ActionGroup, GObject.Object]++instance GObject RemoteActionGroup where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_remote_action_group_get_type+    ++class GObject o => RemoteActionGroupK o+instance (GObject o, IsDescendantOf RemoteActionGroup o) => RemoteActionGroupK o++toRemoteActionGroup :: RemoteActionGroupK o => o -> IO RemoteActionGroup+toRemoteActionGroup = unsafeCastTo RemoteActionGroup++-- method RemoteActionGroup::activate_action_full+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "RemoteActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameter", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "platform_data", argType = TVariant, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "RemoteActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameter", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "platform_data", argType = TVariant, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_remote_action_group_activate_action_full" g_remote_action_group_activate_action_full :: +    Ptr RemoteActionGroup ->                -- _obj : TInterface "Gio" "RemoteActionGroup"+    CString ->                              -- action_name : TBasicType TUTF8+    Ptr GVariant ->                         -- parameter : TVariant+    Ptr GVariant ->                         -- platform_data : TVariant+    IO ()+++remoteActionGroupActivateActionFull ::+    (MonadIO m, RemoteActionGroupK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- action_name+    Maybe (GVariant) ->                     -- parameter+    GVariant ->                             -- platform_data+    m ()+remoteActionGroupActivateActionFull _obj action_name parameter platform_data = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    action_name' <- textToCString action_name+    maybeParameter <- case parameter of+        Nothing -> return nullPtr+        Just jParameter -> do+            let jParameter' = unsafeManagedPtrGetPtr jParameter+            return jParameter'+    let platform_data' = unsafeManagedPtrGetPtr platform_data+    g_remote_action_group_activate_action_full _obj' action_name' maybeParameter platform_data'+    touchManagedPtr _obj+    freeMem action_name'+    return ()++-- method RemoteActionGroup::change_action_state_full+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "RemoteActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TVariant, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "platform_data", argType = TVariant, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "RemoteActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TVariant, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "platform_data", argType = TVariant, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_remote_action_group_change_action_state_full" g_remote_action_group_change_action_state_full :: +    Ptr RemoteActionGroup ->                -- _obj : TInterface "Gio" "RemoteActionGroup"+    CString ->                              -- action_name : TBasicType TUTF8+    Ptr GVariant ->                         -- value : TVariant+    Ptr GVariant ->                         -- platform_data : TVariant+    IO ()+++remoteActionGroupChangeActionStateFull ::+    (MonadIO m, RemoteActionGroupK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- action_name+    GVariant ->                             -- value+    GVariant ->                             -- platform_data+    m ()+remoteActionGroupChangeActionStateFull _obj action_name value platform_data = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    action_name' <- textToCString action_name+    let value' = unsafeManagedPtrGetPtr value+    let platform_data' = unsafeManagedPtrGetPtr platform_data+    g_remote_action_group_change_action_state_full _obj' action_name' value' platform_data'+    touchManagedPtr _obj+    freeMem action_name'+    return ()++
+ GI/Gio/Interfaces/RemoteActionGroup.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Interfaces.RemoteActionGroup where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype RemoteActionGroup = RemoteActionGroup (ForeignPtr RemoteActionGroup)+instance GObject RemoteActionGroup where+class GObject o => RemoteActionGroupK o+instance (GObject o, IsDescendantOf RemoteActionGroup o) => RemoteActionGroupK o
+ GI/Gio/Interfaces/Seekable.hs view
@@ -0,0 +1,239 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Interfaces.Seekable+    ( ++-- * Exported types+    Seekable(..)                            ,+    noSeekable                              ,+    SeekableK                               ,+    toSeekable                              ,+++ -- * Methods+-- ** seekableCanSeek+    seekableCanSeek                         ,+++-- ** seekableCanTruncate+    seekableCanTruncate                     ,+++-- ** seekableSeek+    seekableSeek                            ,+++-- ** seekableTell+    seekableTell                            ,+++-- ** seekableTruncate+    seekableTruncate                        ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++-- interface Seekable ++newtype Seekable = Seekable (ForeignPtr Seekable)+noSeekable :: Maybe Seekable+noSeekable = Nothing++type instance AttributeList Seekable = SeekableAttributeList+type SeekableAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList Seekable = SeekableSignalList+type SeekableSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "g_seekable_get_type"+    c_g_seekable_get_type :: IO GType++type instance ParentTypes Seekable = SeekableParentTypes+type SeekableParentTypes = '[GObject.Object]++instance GObject Seekable where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_seekable_get_type+    ++class GObject o => SeekableK o+instance (GObject o, IsDescendantOf Seekable o) => SeekableK o++toSeekable :: SeekableK o => o -> IO Seekable+toSeekable = unsafeCastTo Seekable++-- method Seekable::can_seek+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Seekable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Seekable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_seekable_can_seek" g_seekable_can_seek :: +    Ptr Seekable ->                         -- _obj : TInterface "Gio" "Seekable"+    IO CInt+++seekableCanSeek ::+    (MonadIO m, SeekableK a) =>+    a ->                                    -- _obj+    m Bool+seekableCanSeek _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_seekable_can_seek _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Seekable::can_truncate+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Seekable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Seekable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_seekable_can_truncate" g_seekable_can_truncate :: +    Ptr Seekable ->                         -- _obj : TInterface "Gio" "Seekable"+    IO CInt+++seekableCanTruncate ::+    (MonadIO m, SeekableK a) =>+    a ->                                    -- _obj+    m Bool+seekableCanTruncate _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_seekable_can_truncate _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Seekable::seek+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Seekable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "offset", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "GLib" "SeekType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Seekable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "offset", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "GLib" "SeekType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_seekable_seek" g_seekable_seek :: +    Ptr Seekable ->                         -- _obj : TInterface "Gio" "Seekable"+    Int64 ->                                -- offset : TBasicType TInt64+    CUInt ->                                -- type : TInterface "GLib" "SeekType"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++seekableSeek ::+    (MonadIO m, SeekableK a, CancellableK b) =>+    a ->                                    -- _obj+    Int64 ->                                -- offset+    GLib.SeekType ->                        -- type+    Maybe (b) ->                            -- cancellable+    m ()+seekableSeek _obj offset type_ cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let type_' = (fromIntegral . fromEnum) type_+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_seekable_seek _obj' offset type_' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method Seekable::tell+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Seekable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Seekable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : False+-- Skip return : False++foreign import ccall "g_seekable_tell" g_seekable_tell :: +    Ptr Seekable ->                         -- _obj : TInterface "Gio" "Seekable"+    IO Int64+++seekableTell ::+    (MonadIO m, SeekableK a) =>+    a ->                                    -- _obj+    m Int64+seekableTell _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_seekable_tell _obj'+    touchManagedPtr _obj+    return result++-- method Seekable::truncate+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Seekable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "offset", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Seekable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "offset", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_seekable_truncate" g_seekable_truncate :: +    Ptr Seekable ->                         -- _obj : TInterface "Gio" "Seekable"+    Int64 ->                                -- offset : TBasicType TInt64+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++seekableTruncate ::+    (MonadIO m, SeekableK a, CancellableK b) =>+    a ->                                    -- _obj+    Int64 ->                                -- offset+    Maybe (b) ->                            -- cancellable+    m ()+seekableTruncate _obj offset cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_seekable_truncate _obj' offset maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++
+ GI/Gio/Interfaces/Seekable.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Interfaces.Seekable where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Seekable = Seekable (ForeignPtr Seekable)+instance GObject Seekable where+class GObject o => SeekableK o+instance (GObject o, IsDescendantOf Seekable o) => SeekableK o
+ GI/Gio/Interfaces/SocketConnectable.hs view
@@ -0,0 +1,123 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Interfaces.SocketConnectable+    ( ++-- * Exported types+    SocketConnectable(..)                   ,+    noSocketConnectable                     ,+    SocketConnectableK                      ,+    toSocketConnectable                     ,+++ -- * Methods+-- ** socketConnectableEnumerate+    socketConnectableEnumerate              ,+++-- ** socketConnectableProxyEnumerate+    socketConnectableProxyEnumerate         ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++-- interface SocketConnectable ++newtype SocketConnectable = SocketConnectable (ForeignPtr SocketConnectable)+noSocketConnectable :: Maybe SocketConnectable+noSocketConnectable = Nothing++type instance AttributeList SocketConnectable = SocketConnectableAttributeList+type SocketConnectableAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList SocketConnectable = SocketConnectableSignalList+type SocketConnectableSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "g_socket_connectable_get_type"+    c_g_socket_connectable_get_type :: IO GType++type instance ParentTypes SocketConnectable = SocketConnectableParentTypes+type SocketConnectableParentTypes = '[GObject.Object]++instance GObject SocketConnectable where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_socket_connectable_get_type+    ++class GObject o => SocketConnectableK o+instance (GObject o, IsDescendantOf SocketConnectable o) => SocketConnectableK o++toSocketConnectable :: SocketConnectableK o => o -> IO SocketConnectable+toSocketConnectable = unsafeCastTo SocketConnectable++-- method SocketConnectable::enumerate+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketConnectable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketConnectable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SocketAddressEnumerator"+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_connectable_enumerate" g_socket_connectable_enumerate :: +    Ptr SocketConnectable ->                -- _obj : TInterface "Gio" "SocketConnectable"+    IO (Ptr SocketAddressEnumerator)+++socketConnectableEnumerate ::+    (MonadIO m, SocketConnectableK a) =>+    a ->                                    -- _obj+    m SocketAddressEnumerator+socketConnectableEnumerate _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_connectable_enumerate _obj'+    checkUnexpectedReturnNULL "g_socket_connectable_enumerate" result+    result' <- (wrapObject SocketAddressEnumerator) result+    touchManagedPtr _obj+    return result'++-- method SocketConnectable::proxy_enumerate+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketConnectable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketConnectable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SocketAddressEnumerator"+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_connectable_proxy_enumerate" g_socket_connectable_proxy_enumerate :: +    Ptr SocketConnectable ->                -- _obj : TInterface "Gio" "SocketConnectable"+    IO (Ptr SocketAddressEnumerator)+++socketConnectableProxyEnumerate ::+    (MonadIO m, SocketConnectableK a) =>+    a ->                                    -- _obj+    m SocketAddressEnumerator+socketConnectableProxyEnumerate _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_connectable_proxy_enumerate _obj'+    checkUnexpectedReturnNULL "g_socket_connectable_proxy_enumerate" result+    result' <- (wrapObject SocketAddressEnumerator) result+    touchManagedPtr _obj+    return result'++
+ GI/Gio/Interfaces/SocketConnectable.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Interfaces.SocketConnectable where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype SocketConnectable = SocketConnectable (ForeignPtr SocketConnectable)+instance GObject SocketConnectable where+class GObject o => SocketConnectableK o+instance (GObject o, IsDescendantOf SocketConnectable o) => SocketConnectableK o
+ GI/Gio/Interfaces/TlsBackend.hs view
@@ -0,0 +1,238 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Interfaces.TlsBackend+    ( ++-- * Exported types+    TlsBackend(..)                          ,+    noTlsBackend                            ,+    TlsBackendK                             ,+    toTlsBackend                            ,+++ -- * Methods+-- ** tlsBackendGetCertificateType+    tlsBackendGetCertificateType            ,+++-- ** tlsBackendGetClientConnectionType+    tlsBackendGetClientConnectionType       ,+++-- ** tlsBackendGetDefaultDatabase+    tlsBackendGetDefaultDatabase            ,+++-- ** tlsBackendGetFileDatabaseType+    tlsBackendGetFileDatabaseType           ,+++-- ** tlsBackendGetServerConnectionType+    tlsBackendGetServerConnectionType       ,+++-- ** tlsBackendSupportsTls+    tlsBackendSupportsTls                   ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++-- interface TlsBackend ++newtype TlsBackend = TlsBackend (ForeignPtr TlsBackend)+noTlsBackend :: Maybe TlsBackend+noTlsBackend = Nothing++type instance AttributeList TlsBackend = TlsBackendAttributeList+type TlsBackendAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList TlsBackend = TlsBackendSignalList+type TlsBackendSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "g_tls_backend_get_type"+    c_g_tls_backend_get_type :: IO GType++type instance ParentTypes TlsBackend = TlsBackendParentTypes+type TlsBackendParentTypes = '[GObject.Object]++instance GObject TlsBackend where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_tls_backend_get_type+    ++class GObject o => TlsBackendK o+instance (GObject o, IsDescendantOf TlsBackend o) => TlsBackendK o++toTlsBackend :: TlsBackendK o => o -> IO TlsBackend+toTlsBackend = unsafeCastTo TlsBackend++-- method TlsBackend::get_certificate_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsBackend", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsBackend", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TGType+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_backend_get_certificate_type" g_tls_backend_get_certificate_type :: +    Ptr TlsBackend ->                       -- _obj : TInterface "Gio" "TlsBackend"+    IO CGType+++tlsBackendGetCertificateType ::+    (MonadIO m, TlsBackendK a) =>+    a ->                                    -- _obj+    m GType+tlsBackendGetCertificateType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_tls_backend_get_certificate_type _obj'+    let result' = GType result+    touchManagedPtr _obj+    return result'++-- method TlsBackend::get_client_connection_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsBackend", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsBackend", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TGType+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_backend_get_client_connection_type" g_tls_backend_get_client_connection_type :: +    Ptr TlsBackend ->                       -- _obj : TInterface "Gio" "TlsBackend"+    IO CGType+++tlsBackendGetClientConnectionType ::+    (MonadIO m, TlsBackendK a) =>+    a ->                                    -- _obj+    m GType+tlsBackendGetClientConnectionType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_tls_backend_get_client_connection_type _obj'+    let result' = GType result+    touchManagedPtr _obj+    return result'++-- method TlsBackend::get_default_database+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsBackend", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsBackend", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TlsDatabase"+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_backend_get_default_database" g_tls_backend_get_default_database :: +    Ptr TlsBackend ->                       -- _obj : TInterface "Gio" "TlsBackend"+    IO (Ptr TlsDatabase)+++tlsBackendGetDefaultDatabase ::+    (MonadIO m, TlsBackendK a) =>+    a ->                                    -- _obj+    m TlsDatabase+tlsBackendGetDefaultDatabase _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_tls_backend_get_default_database _obj'+    checkUnexpectedReturnNULL "g_tls_backend_get_default_database" result+    result' <- (wrapObject TlsDatabase) result+    touchManagedPtr _obj+    return result'++-- method TlsBackend::get_file_database_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsBackend", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsBackend", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TGType+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_backend_get_file_database_type" g_tls_backend_get_file_database_type :: +    Ptr TlsBackend ->                       -- _obj : TInterface "Gio" "TlsBackend"+    IO CGType+++tlsBackendGetFileDatabaseType ::+    (MonadIO m, TlsBackendK a) =>+    a ->                                    -- _obj+    m GType+tlsBackendGetFileDatabaseType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_tls_backend_get_file_database_type _obj'+    let result' = GType result+    touchManagedPtr _obj+    return result'++-- method TlsBackend::get_server_connection_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsBackend", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsBackend", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TGType+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_backend_get_server_connection_type" g_tls_backend_get_server_connection_type :: +    Ptr TlsBackend ->                       -- _obj : TInterface "Gio" "TlsBackend"+    IO CGType+++tlsBackendGetServerConnectionType ::+    (MonadIO m, TlsBackendK a) =>+    a ->                                    -- _obj+    m GType+tlsBackendGetServerConnectionType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_tls_backend_get_server_connection_type _obj'+    let result' = GType result+    touchManagedPtr _obj+    return result'++-- method TlsBackend::supports_tls+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsBackend", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsBackend", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_backend_supports_tls" g_tls_backend_supports_tls :: +    Ptr TlsBackend ->                       -- _obj : TInterface "Gio" "TlsBackend"+    IO CInt+++tlsBackendSupportsTls ::+    (MonadIO m, TlsBackendK a) =>+    a ->                                    -- _obj+    m Bool+tlsBackendSupportsTls _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_tls_backend_supports_tls _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++
+ GI/Gio/Interfaces/TlsBackend.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Interfaces.TlsBackend where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype TlsBackend = TlsBackend (ForeignPtr TlsBackend)+instance GObject TlsBackend where+class GObject o => TlsBackendK o+instance (GObject o, IsDescendantOf TlsBackend o) => TlsBackendK o
+ GI/Gio/Interfaces/TlsClientConnection.hs view
@@ -0,0 +1,429 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Interfaces.TlsClientConnection+    ( ++-- * Exported types+    TlsClientConnection(..)                 ,+    noTlsClientConnection                   ,+    TlsClientConnectionK                    ,+    toTlsClientConnection                   ,+++ -- * Methods+-- ** tlsClientConnectionCopySessionState+    tlsClientConnectionCopySessionState     ,+++-- ** tlsClientConnectionGetAcceptedCas+    tlsClientConnectionGetAcceptedCas       ,+++-- ** tlsClientConnectionGetServerIdentity+    tlsClientConnectionGetServerIdentity    ,+++-- ** tlsClientConnectionGetUseSsl3+    tlsClientConnectionGetUseSsl3           ,+++-- ** tlsClientConnectionGetValidationFlags+    tlsClientConnectionGetValidationFlags   ,+++-- ** tlsClientConnectionSetServerIdentity+    tlsClientConnectionSetServerIdentity    ,+++-- ** tlsClientConnectionSetUseSsl3+    tlsClientConnectionSetUseSsl3           ,+++-- ** tlsClientConnectionSetValidationFlags+    tlsClientConnectionSetValidationFlags   ,+++++ -- * Properties+-- ** AcceptedCas+    TlsClientConnectionAcceptedCasPropertyInfo,+    getTlsClientConnectionAcceptedCas       ,+++-- ** ServerIdentity+    TlsClientConnectionServerIdentityPropertyInfo,+    constructTlsClientConnectionServerIdentity,+    getTlsClientConnectionServerIdentity    ,+    setTlsClientConnectionServerIdentity    ,+++-- ** UseSsl3+    TlsClientConnectionUseSsl3PropertyInfo  ,+    constructTlsClientConnectionUseSsl3     ,+    getTlsClientConnectionUseSsl3           ,+    setTlsClientConnectionUseSsl3           ,+++-- ** ValidationFlags+    TlsClientConnectionValidationFlagsPropertyInfo,+    constructTlsClientConnectionValidationFlags,+    getTlsClientConnectionValidationFlags   ,+    setTlsClientConnectionValidationFlags   ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++-- interface TlsClientConnection ++newtype TlsClientConnection = TlsClientConnection (ForeignPtr TlsClientConnection)+noTlsClientConnection :: Maybe TlsClientConnection+noTlsClientConnection = Nothing++-- VVV Prop "accepted-cas"+   -- Type: TGList (TBasicType TVoid)+   -- Flags: [PropertyReadable]++getTlsClientConnectionAcceptedCas :: (MonadIO m, TlsClientConnectionK o) => o -> m [Ptr ()]+getTlsClientConnectionAcceptedCas obj = liftIO $ getObjectPropertyPtrGList obj "accepted-cas"++data TlsClientConnectionAcceptedCasPropertyInfo+instance AttrInfo TlsClientConnectionAcceptedCasPropertyInfo where+    type AttrAllowedOps TlsClientConnectionAcceptedCasPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint TlsClientConnectionAcceptedCasPropertyInfo = (~) ()+    type AttrBaseTypeConstraint TlsClientConnectionAcceptedCasPropertyInfo = TlsClientConnectionK+    type AttrGetType TlsClientConnectionAcceptedCasPropertyInfo = ([Ptr ()])+    type AttrLabel TlsClientConnectionAcceptedCasPropertyInfo = "TlsClientConnection::accepted-cas"+    attrGet _ = getTlsClientConnectionAcceptedCas+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "server-identity"+   -- Type: TInterface "Gio" "SocketConnectable"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getTlsClientConnectionServerIdentity :: (MonadIO m, TlsClientConnectionK o) => o -> m SocketConnectable+getTlsClientConnectionServerIdentity obj = liftIO $ getObjectPropertyObject obj "server-identity" SocketConnectable++setTlsClientConnectionServerIdentity :: (MonadIO m, TlsClientConnectionK o, SocketConnectableK a) => o -> a -> m ()+setTlsClientConnectionServerIdentity obj val = liftIO $ setObjectPropertyObject obj "server-identity" val++constructTlsClientConnectionServerIdentity :: (SocketConnectableK a) => a -> IO ([Char], GValue)+constructTlsClientConnectionServerIdentity val = constructObjectPropertyObject "server-identity" val++data TlsClientConnectionServerIdentityPropertyInfo+instance AttrInfo TlsClientConnectionServerIdentityPropertyInfo where+    type AttrAllowedOps TlsClientConnectionServerIdentityPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TlsClientConnectionServerIdentityPropertyInfo = SocketConnectableK+    type AttrBaseTypeConstraint TlsClientConnectionServerIdentityPropertyInfo = TlsClientConnectionK+    type AttrGetType TlsClientConnectionServerIdentityPropertyInfo = SocketConnectable+    type AttrLabel TlsClientConnectionServerIdentityPropertyInfo = "TlsClientConnection::server-identity"+    attrGet _ = getTlsClientConnectionServerIdentity+    attrSet _ = setTlsClientConnectionServerIdentity+    attrConstruct _ = constructTlsClientConnectionServerIdentity++-- VVV Prop "use-ssl3"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getTlsClientConnectionUseSsl3 :: (MonadIO m, TlsClientConnectionK o) => o -> m Bool+getTlsClientConnectionUseSsl3 obj = liftIO $ getObjectPropertyBool obj "use-ssl3"++setTlsClientConnectionUseSsl3 :: (MonadIO m, TlsClientConnectionK o) => o -> Bool -> m ()+setTlsClientConnectionUseSsl3 obj val = liftIO $ setObjectPropertyBool obj "use-ssl3" val++constructTlsClientConnectionUseSsl3 :: Bool -> IO ([Char], GValue)+constructTlsClientConnectionUseSsl3 val = constructObjectPropertyBool "use-ssl3" val++data TlsClientConnectionUseSsl3PropertyInfo+instance AttrInfo TlsClientConnectionUseSsl3PropertyInfo where+    type AttrAllowedOps TlsClientConnectionUseSsl3PropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TlsClientConnectionUseSsl3PropertyInfo = (~) Bool+    type AttrBaseTypeConstraint TlsClientConnectionUseSsl3PropertyInfo = TlsClientConnectionK+    type AttrGetType TlsClientConnectionUseSsl3PropertyInfo = Bool+    type AttrLabel TlsClientConnectionUseSsl3PropertyInfo = "TlsClientConnection::use-ssl3"+    attrGet _ = getTlsClientConnectionUseSsl3+    attrSet _ = setTlsClientConnectionUseSsl3+    attrConstruct _ = constructTlsClientConnectionUseSsl3++-- VVV Prop "validation-flags"+   -- Type: TInterface "Gio" "TlsCertificateFlags"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getTlsClientConnectionValidationFlags :: (MonadIO m, TlsClientConnectionK o) => o -> m [TlsCertificateFlags]+getTlsClientConnectionValidationFlags obj = liftIO $ getObjectPropertyFlags obj "validation-flags"++setTlsClientConnectionValidationFlags :: (MonadIO m, TlsClientConnectionK o) => o -> [TlsCertificateFlags] -> m ()+setTlsClientConnectionValidationFlags obj val = liftIO $ setObjectPropertyFlags obj "validation-flags" val++constructTlsClientConnectionValidationFlags :: [TlsCertificateFlags] -> IO ([Char], GValue)+constructTlsClientConnectionValidationFlags val = constructObjectPropertyFlags "validation-flags" val++data TlsClientConnectionValidationFlagsPropertyInfo+instance AttrInfo TlsClientConnectionValidationFlagsPropertyInfo where+    type AttrAllowedOps TlsClientConnectionValidationFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TlsClientConnectionValidationFlagsPropertyInfo = (~) [TlsCertificateFlags]+    type AttrBaseTypeConstraint TlsClientConnectionValidationFlagsPropertyInfo = TlsClientConnectionK+    type AttrGetType TlsClientConnectionValidationFlagsPropertyInfo = [TlsCertificateFlags]+    type AttrLabel TlsClientConnectionValidationFlagsPropertyInfo = "TlsClientConnection::validation-flags"+    attrGet _ = getTlsClientConnectionValidationFlags+    attrSet _ = setTlsClientConnectionValidationFlags+    attrConstruct _ = constructTlsClientConnectionValidationFlags++type instance AttributeList TlsClientConnection = TlsClientConnectionAttributeList+type TlsClientConnectionAttributeList = ('[ '("accepted-cas", TlsClientConnectionAcceptedCasPropertyInfo), '("base-io-stream", TlsConnectionBaseIoStreamPropertyInfo), '("certificate", TlsConnectionCertificatePropertyInfo), '("closed", IOStreamClosedPropertyInfo), '("database", TlsConnectionDatabasePropertyInfo), '("input-stream", IOStreamInputStreamPropertyInfo), '("interaction", TlsConnectionInteractionPropertyInfo), '("output-stream", IOStreamOutputStreamPropertyInfo), '("peer-certificate", TlsConnectionPeerCertificatePropertyInfo), '("peer-certificate-errors", TlsConnectionPeerCertificateErrorsPropertyInfo), '("rehandshake-mode", TlsConnectionRehandshakeModePropertyInfo), '("require-close-notify", TlsConnectionRequireCloseNotifyPropertyInfo), '("server-identity", TlsClientConnectionServerIdentityPropertyInfo), '("use-ssl3", TlsClientConnectionUseSsl3PropertyInfo), '("use-system-certdb", TlsConnectionUseSystemCertdbPropertyInfo), '("validation-flags", TlsClientConnectionValidationFlagsPropertyInfo)] :: [(Symbol, *)])++type instance SignalList TlsClientConnection = TlsClientConnectionSignalList+type TlsClientConnectionSignalList = ('[ '("accept-certificate", TlsConnectionAcceptCertificateSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "g_tls_client_connection_get_type"+    c_g_tls_client_connection_get_type :: IO GType++type instance ParentTypes TlsClientConnection = TlsClientConnectionParentTypes+type TlsClientConnectionParentTypes = '[TlsConnection, IOStream, GObject.Object]++instance GObject TlsClientConnection where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_tls_client_connection_get_type+    ++class GObject o => TlsClientConnectionK o+instance (GObject o, IsDescendantOf TlsClientConnection o) => TlsClientConnectionK o++toTlsClientConnection :: TlsClientConnectionK o => o -> IO TlsClientConnection+toTlsClientConnection = unsafeCastTo TlsClientConnection++-- method TlsClientConnection::copy_session_state+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsClientConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source", argType = TInterface "Gio" "TlsClientConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsClientConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source", argType = TInterface "Gio" "TlsClientConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_client_connection_copy_session_state" g_tls_client_connection_copy_session_state :: +    Ptr TlsClientConnection ->              -- _obj : TInterface "Gio" "TlsClientConnection"+    Ptr TlsClientConnection ->              -- source : TInterface "Gio" "TlsClientConnection"+    IO ()+++tlsClientConnectionCopySessionState ::+    (MonadIO m, TlsClientConnectionK a, TlsClientConnectionK b) =>+    a ->                                    -- _obj+    b ->                                    -- source+    m ()+tlsClientConnectionCopySessionState _obj source = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let source' = unsafeManagedPtrCastPtr source+    g_tls_client_connection_copy_session_state _obj' source'+    touchManagedPtr _obj+    touchManagedPtr source+    return ()++-- method TlsClientConnection::get_accepted_cas+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsClientConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsClientConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList TByteArray+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_client_connection_get_accepted_cas" g_tls_client_connection_get_accepted_cas :: +    Ptr TlsClientConnection ->              -- _obj : TInterface "Gio" "TlsClientConnection"+    IO (Ptr (GList (Ptr GByteArray)))+++tlsClientConnectionGetAcceptedCas ::+    (MonadIO m, TlsClientConnectionK a) =>+    a ->                                    -- _obj+    m [ByteString]+tlsClientConnectionGetAcceptedCas _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_tls_client_connection_get_accepted_cas _obj'+    checkUnexpectedReturnNULL "g_tls_client_connection_get_accepted_cas" result+    result' <- unpackGList result+    result'' <- mapM unpackGByteArray result'+    mapGList unrefGByteArray result+    g_list_free result+    touchManagedPtr _obj+    return result''++-- method TlsClientConnection::get_server_identity+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsClientConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsClientConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SocketConnectable"+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_client_connection_get_server_identity" g_tls_client_connection_get_server_identity :: +    Ptr TlsClientConnection ->              -- _obj : TInterface "Gio" "TlsClientConnection"+    IO (Ptr SocketConnectable)+++tlsClientConnectionGetServerIdentity ::+    (MonadIO m, TlsClientConnectionK a) =>+    a ->                                    -- _obj+    m SocketConnectable+tlsClientConnectionGetServerIdentity _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_tls_client_connection_get_server_identity _obj'+    checkUnexpectedReturnNULL "g_tls_client_connection_get_server_identity" result+    result' <- (newObject SocketConnectable) result+    touchManagedPtr _obj+    return result'++-- method TlsClientConnection::get_use_ssl3+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsClientConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsClientConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_client_connection_get_use_ssl3" g_tls_client_connection_get_use_ssl3 :: +    Ptr TlsClientConnection ->              -- _obj : TInterface "Gio" "TlsClientConnection"+    IO CInt+++tlsClientConnectionGetUseSsl3 ::+    (MonadIO m, TlsClientConnectionK a) =>+    a ->                                    -- _obj+    m Bool+tlsClientConnectionGetUseSsl3 _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_tls_client_connection_get_use_ssl3 _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method TlsClientConnection::get_validation_flags+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsClientConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsClientConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TlsCertificateFlags"+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_client_connection_get_validation_flags" g_tls_client_connection_get_validation_flags :: +    Ptr TlsClientConnection ->              -- _obj : TInterface "Gio" "TlsClientConnection"+    IO CUInt+++tlsClientConnectionGetValidationFlags ::+    (MonadIO m, TlsClientConnectionK a) =>+    a ->                                    -- _obj+    m [TlsCertificateFlags]+tlsClientConnectionGetValidationFlags _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_tls_client_connection_get_validation_flags _obj'+    let result' = wordToGFlags result+    touchManagedPtr _obj+    return result'++-- method TlsClientConnection::set_server_identity+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsClientConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "identity", argType = TInterface "Gio" "SocketConnectable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsClientConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "identity", argType = TInterface "Gio" "SocketConnectable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_client_connection_set_server_identity" g_tls_client_connection_set_server_identity :: +    Ptr TlsClientConnection ->              -- _obj : TInterface "Gio" "TlsClientConnection"+    Ptr SocketConnectable ->                -- identity : TInterface "Gio" "SocketConnectable"+    IO ()+++tlsClientConnectionSetServerIdentity ::+    (MonadIO m, TlsClientConnectionK a, SocketConnectableK b) =>+    a ->                                    -- _obj+    b ->                                    -- identity+    m ()+tlsClientConnectionSetServerIdentity _obj identity = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let identity' = unsafeManagedPtrCastPtr identity+    g_tls_client_connection_set_server_identity _obj' identity'+    touchManagedPtr _obj+    touchManagedPtr identity+    return ()++-- method TlsClientConnection::set_use_ssl3+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsClientConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_ssl3", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsClientConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_ssl3", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_client_connection_set_use_ssl3" g_tls_client_connection_set_use_ssl3 :: +    Ptr TlsClientConnection ->              -- _obj : TInterface "Gio" "TlsClientConnection"+    CInt ->                                 -- use_ssl3 : TBasicType TBoolean+    IO ()+++tlsClientConnectionSetUseSsl3 ::+    (MonadIO m, TlsClientConnectionK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- use_ssl3+    m ()+tlsClientConnectionSetUseSsl3 _obj use_ssl3 = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let use_ssl3' = (fromIntegral . fromEnum) use_ssl3+    g_tls_client_connection_set_use_ssl3 _obj' use_ssl3'+    touchManagedPtr _obj+    return ()++-- method TlsClientConnection::set_validation_flags+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsClientConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "TlsCertificateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsClientConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "TlsCertificateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_client_connection_set_validation_flags" g_tls_client_connection_set_validation_flags :: +    Ptr TlsClientConnection ->              -- _obj : TInterface "Gio" "TlsClientConnection"+    CUInt ->                                -- flags : TInterface "Gio" "TlsCertificateFlags"+    IO ()+++tlsClientConnectionSetValidationFlags ::+    (MonadIO m, TlsClientConnectionK a) =>+    a ->                                    -- _obj+    [TlsCertificateFlags] ->                -- flags+    m ()+tlsClientConnectionSetValidationFlags _obj flags = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    g_tls_client_connection_set_validation_flags _obj' flags'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Interfaces/TlsClientConnection.hs-boot view
@@ -0,0 +1,17 @@+module GI.Gio.Interfaces.TlsClientConnection where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype TlsClientConnection = TlsClientConnection (ForeignPtr TlsClientConnection)+data TlsClientConnectionAcceptedCasPropertyInfo+data TlsClientConnectionServerIdentityPropertyInfo+data TlsClientConnectionUseSsl3PropertyInfo+data TlsClientConnectionValidationFlagsPropertyInfo+instance GObject TlsClientConnection where+class GObject o => TlsClientConnectionK o+instance (GObject o, IsDescendantOf TlsClientConnection o) => TlsClientConnectionK o
+ GI/Gio/Interfaces/TlsFileDatabase.hs view
@@ -0,0 +1,94 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Interfaces.TlsFileDatabase+    ( ++-- * Exported types+    TlsFileDatabase(..)                     ,+    noTlsFileDatabase                       ,+    TlsFileDatabaseK                        ,+    toTlsFileDatabase                       ,+++ -- * Properties+-- ** Anchors+    TlsFileDatabaseAnchorsPropertyInfo      ,+    constructTlsFileDatabaseAnchors         ,+    getTlsFileDatabaseAnchors               ,+    setTlsFileDatabaseAnchors               ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++-- interface TlsFileDatabase ++newtype TlsFileDatabase = TlsFileDatabase (ForeignPtr TlsFileDatabase)+noTlsFileDatabase :: Maybe TlsFileDatabase+noTlsFileDatabase = Nothing++-- VVV Prop "anchors"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getTlsFileDatabaseAnchors :: (MonadIO m, TlsFileDatabaseK o) => o -> m T.Text+getTlsFileDatabaseAnchors obj = liftIO $ getObjectPropertyString obj "anchors"++setTlsFileDatabaseAnchors :: (MonadIO m, TlsFileDatabaseK o) => o -> T.Text -> m ()+setTlsFileDatabaseAnchors obj val = liftIO $ setObjectPropertyString obj "anchors" val++constructTlsFileDatabaseAnchors :: T.Text -> IO ([Char], GValue)+constructTlsFileDatabaseAnchors val = constructObjectPropertyString "anchors" val++data TlsFileDatabaseAnchorsPropertyInfo+instance AttrInfo TlsFileDatabaseAnchorsPropertyInfo where+    type AttrAllowedOps TlsFileDatabaseAnchorsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TlsFileDatabaseAnchorsPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint TlsFileDatabaseAnchorsPropertyInfo = TlsFileDatabaseK+    type AttrGetType TlsFileDatabaseAnchorsPropertyInfo = T.Text+    type AttrLabel TlsFileDatabaseAnchorsPropertyInfo = "TlsFileDatabase::anchors"+    attrGet _ = getTlsFileDatabaseAnchors+    attrSet _ = setTlsFileDatabaseAnchors+    attrConstruct _ = constructTlsFileDatabaseAnchors++type instance AttributeList TlsFileDatabase = TlsFileDatabaseAttributeList+type TlsFileDatabaseAttributeList = ('[ '("anchors", TlsFileDatabaseAnchorsPropertyInfo)] :: [(Symbol, *)])++type instance SignalList TlsFileDatabase = TlsFileDatabaseSignalList+type TlsFileDatabaseSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "g_tls_file_database_get_type"+    c_g_tls_file_database_get_type :: IO GType++type instance ParentTypes TlsFileDatabase = TlsFileDatabaseParentTypes+type TlsFileDatabaseParentTypes = '[TlsDatabase, GObject.Object]++instance GObject TlsFileDatabase where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_tls_file_database_get_type+    ++class GObject o => TlsFileDatabaseK o+instance (GObject o, IsDescendantOf TlsFileDatabase o) => TlsFileDatabaseK o++toTlsFileDatabase :: TlsFileDatabaseK o => o -> IO TlsFileDatabase+toTlsFileDatabase = unsafeCastTo TlsFileDatabase++
+ GI/Gio/Interfaces/TlsFileDatabase.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gio.Interfaces.TlsFileDatabase where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype TlsFileDatabase = TlsFileDatabase (ForeignPtr TlsFileDatabase)+data TlsFileDatabaseAnchorsPropertyInfo+instance GObject TlsFileDatabase where+class GObject o => TlsFileDatabaseK o+instance (GObject o, IsDescendantOf TlsFileDatabase o) => TlsFileDatabaseK o
+ GI/Gio/Interfaces/TlsServerConnection.hs view
@@ -0,0 +1,94 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Interfaces.TlsServerConnection+    ( ++-- * Exported types+    TlsServerConnection(..)                 ,+    noTlsServerConnection                   ,+    TlsServerConnectionK                    ,+    toTlsServerConnection                   ,+++ -- * Properties+-- ** AuthenticationMode+    TlsServerConnectionAuthenticationModePropertyInfo,+    constructTlsServerConnectionAuthenticationMode,+    getTlsServerConnectionAuthenticationMode,+    setTlsServerConnectionAuthenticationMode,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++-- interface TlsServerConnection ++newtype TlsServerConnection = TlsServerConnection (ForeignPtr TlsServerConnection)+noTlsServerConnection :: Maybe TlsServerConnection+noTlsServerConnection = Nothing++-- VVV Prop "authentication-mode"+   -- Type: TInterface "Gio" "TlsAuthenticationMode"+   -- Flags: [PropertyReadable,PropertyWritable]++getTlsServerConnectionAuthenticationMode :: (MonadIO m, TlsServerConnectionK o) => o -> m TlsAuthenticationMode+getTlsServerConnectionAuthenticationMode obj = liftIO $ getObjectPropertyEnum obj "authentication-mode"++setTlsServerConnectionAuthenticationMode :: (MonadIO m, TlsServerConnectionK o) => o -> TlsAuthenticationMode -> m ()+setTlsServerConnectionAuthenticationMode obj val = liftIO $ setObjectPropertyEnum obj "authentication-mode" val++constructTlsServerConnectionAuthenticationMode :: TlsAuthenticationMode -> IO ([Char], GValue)+constructTlsServerConnectionAuthenticationMode val = constructObjectPropertyEnum "authentication-mode" val++data TlsServerConnectionAuthenticationModePropertyInfo+instance AttrInfo TlsServerConnectionAuthenticationModePropertyInfo where+    type AttrAllowedOps TlsServerConnectionAuthenticationModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TlsServerConnectionAuthenticationModePropertyInfo = (~) TlsAuthenticationMode+    type AttrBaseTypeConstraint TlsServerConnectionAuthenticationModePropertyInfo = TlsServerConnectionK+    type AttrGetType TlsServerConnectionAuthenticationModePropertyInfo = TlsAuthenticationMode+    type AttrLabel TlsServerConnectionAuthenticationModePropertyInfo = "TlsServerConnection::authentication-mode"+    attrGet _ = getTlsServerConnectionAuthenticationMode+    attrSet _ = setTlsServerConnectionAuthenticationMode+    attrConstruct _ = constructTlsServerConnectionAuthenticationMode++type instance AttributeList TlsServerConnection = TlsServerConnectionAttributeList+type TlsServerConnectionAttributeList = ('[ '("authentication-mode", TlsServerConnectionAuthenticationModePropertyInfo), '("base-io-stream", TlsConnectionBaseIoStreamPropertyInfo), '("certificate", TlsConnectionCertificatePropertyInfo), '("closed", IOStreamClosedPropertyInfo), '("database", TlsConnectionDatabasePropertyInfo), '("input-stream", IOStreamInputStreamPropertyInfo), '("interaction", TlsConnectionInteractionPropertyInfo), '("output-stream", IOStreamOutputStreamPropertyInfo), '("peer-certificate", TlsConnectionPeerCertificatePropertyInfo), '("peer-certificate-errors", TlsConnectionPeerCertificateErrorsPropertyInfo), '("rehandshake-mode", TlsConnectionRehandshakeModePropertyInfo), '("require-close-notify", TlsConnectionRequireCloseNotifyPropertyInfo), '("use-system-certdb", TlsConnectionUseSystemCertdbPropertyInfo)] :: [(Symbol, *)])++type instance SignalList TlsServerConnection = TlsServerConnectionSignalList+type TlsServerConnectionSignalList = ('[ '("accept-certificate", TlsConnectionAcceptCertificateSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "g_tls_server_connection_get_type"+    c_g_tls_server_connection_get_type :: IO GType++type instance ParentTypes TlsServerConnection = TlsServerConnectionParentTypes+type TlsServerConnectionParentTypes = '[TlsConnection, IOStream, GObject.Object]++instance GObject TlsServerConnection where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_tls_server_connection_get_type+    ++class GObject o => TlsServerConnectionK o+instance (GObject o, IsDescendantOf TlsServerConnection o) => TlsServerConnectionK o++toTlsServerConnection :: TlsServerConnectionK o => o -> IO TlsServerConnection+toTlsServerConnection = unsafeCastTo TlsServerConnection++
+ GI/Gio/Interfaces/TlsServerConnection.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gio.Interfaces.TlsServerConnection where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype TlsServerConnection = TlsServerConnection (ForeignPtr TlsServerConnection)+data TlsServerConnectionAuthenticationModePropertyInfo+instance GObject TlsServerConnection where+class GObject o => TlsServerConnectionK o+instance (GObject o, IsDescendantOf TlsServerConnection o) => TlsServerConnectionK o
+ GI/Gio/Interfaces/Volume.hs view
@@ -0,0 +1,849 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Interfaces.Volume+    ( ++-- * Exported types+    Volume(..)                              ,+    noVolume                                ,+    VolumeK                                 ,+    toVolume                                ,+++ -- * Methods+-- ** volumeCanEject+    volumeCanEject                          ,+++-- ** volumeCanMount+    volumeCanMount                          ,+++-- ** volumeEject+    volumeEject                             ,+++-- ** volumeEjectFinish+    volumeEjectFinish                       ,+++-- ** volumeEjectWithOperation+    volumeEjectWithOperation                ,+++-- ** volumeEjectWithOperationFinish+    volumeEjectWithOperationFinish          ,+++-- ** volumeEnumerateIdentifiers+    volumeEnumerateIdentifiers              ,+++-- ** volumeGetActivationRoot+    volumeGetActivationRoot                 ,+++-- ** volumeGetDrive+    volumeGetDrive                          ,+++-- ** volumeGetIcon+    volumeGetIcon                           ,+++-- ** volumeGetIdentifier+    volumeGetIdentifier                     ,+++-- ** volumeGetMount+    volumeGetMount                          ,+++-- ** volumeGetName+    volumeGetName                           ,+++-- ** volumeGetSortKey+    volumeGetSortKey                        ,+++-- ** volumeGetSymbolicIcon+    volumeGetSymbolicIcon                   ,+++-- ** volumeGetUuid+    volumeGetUuid                           ,+++-- ** volumeMount+    volumeMount                             ,+++-- ** volumeMountFinish+    volumeMountFinish                       ,+++-- ** volumeShouldAutomount+    volumeShouldAutomount                   ,+++++ -- * Signals+-- ** Changed+    VolumeChangedCallback                   ,+    VolumeChangedCallbackC                  ,+    VolumeChangedSignalInfo                 ,+    afterVolumeChanged                      ,+    mkVolumeChangedCallback                 ,+    noVolumeChangedCallback                 ,+    onVolumeChanged                         ,+    volumeChangedCallbackWrapper            ,+    volumeChangedClosure                    ,+++-- ** Removed+    VolumeRemovedCallback                   ,+    VolumeRemovedCallbackC                  ,+    VolumeRemovedSignalInfo                 ,+    afterVolumeRemoved                      ,+    mkVolumeRemovedCallback                 ,+    noVolumeRemovedCallback                 ,+    onVolumeRemoved                         ,+    volumeRemovedCallbackWrapper            ,+    volumeRemovedClosure                    ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++-- interface Volume ++newtype Volume = Volume (ForeignPtr Volume)+noVolume :: Maybe Volume+noVolume = Nothing++-- signal Volume::changed+type VolumeChangedCallback =+    IO ()++noVolumeChangedCallback :: Maybe VolumeChangedCallback+noVolumeChangedCallback = Nothing++type VolumeChangedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkVolumeChangedCallback :: VolumeChangedCallbackC -> IO (FunPtr VolumeChangedCallbackC)++volumeChangedClosure :: VolumeChangedCallback -> IO Closure+volumeChangedClosure cb = newCClosure =<< mkVolumeChangedCallback wrapped+    where wrapped = volumeChangedCallbackWrapper cb++volumeChangedCallbackWrapper ::+    VolumeChangedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+volumeChangedCallbackWrapper _cb _ _ = do+    _cb ++onVolumeChanged :: (GObject a, MonadIO m) => a -> VolumeChangedCallback -> m SignalHandlerId+onVolumeChanged obj cb = liftIO $ connectVolumeChanged obj cb SignalConnectBefore+afterVolumeChanged :: (GObject a, MonadIO m) => a -> VolumeChangedCallback -> m SignalHandlerId+afterVolumeChanged obj cb = connectVolumeChanged obj cb SignalConnectAfter++connectVolumeChanged :: (GObject a, MonadIO m) =>+                        a -> VolumeChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectVolumeChanged obj cb after = liftIO $ do+    cb' <- mkVolumeChangedCallback (volumeChangedCallbackWrapper cb)+    connectSignalFunPtr obj "changed" cb' after++-- signal Volume::removed+type VolumeRemovedCallback =+    IO ()++noVolumeRemovedCallback :: Maybe VolumeRemovedCallback+noVolumeRemovedCallback = Nothing++type VolumeRemovedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkVolumeRemovedCallback :: VolumeRemovedCallbackC -> IO (FunPtr VolumeRemovedCallbackC)++volumeRemovedClosure :: VolumeRemovedCallback -> IO Closure+volumeRemovedClosure cb = newCClosure =<< mkVolumeRemovedCallback wrapped+    where wrapped = volumeRemovedCallbackWrapper cb++volumeRemovedCallbackWrapper ::+    VolumeRemovedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+volumeRemovedCallbackWrapper _cb _ _ = do+    _cb ++onVolumeRemoved :: (GObject a, MonadIO m) => a -> VolumeRemovedCallback -> m SignalHandlerId+onVolumeRemoved obj cb = liftIO $ connectVolumeRemoved obj cb SignalConnectBefore+afterVolumeRemoved :: (GObject a, MonadIO m) => a -> VolumeRemovedCallback -> m SignalHandlerId+afterVolumeRemoved obj cb = connectVolumeRemoved obj cb SignalConnectAfter++connectVolumeRemoved :: (GObject a, MonadIO m) =>+                        a -> VolumeRemovedCallback -> SignalConnectMode -> m SignalHandlerId+connectVolumeRemoved obj cb after = liftIO $ do+    cb' <- mkVolumeRemovedCallback (volumeRemovedCallbackWrapper cb)+    connectSignalFunPtr obj "removed" cb' after++type instance AttributeList Volume = VolumeAttributeList+type VolumeAttributeList = ('[ ] :: [(Symbol, *)])++data VolumeChangedSignalInfo+instance SignalInfo VolumeChangedSignalInfo where+    type HaskellCallbackType VolumeChangedSignalInfo = VolumeChangedCallback+    connectSignal _ = connectVolumeChanged++data VolumeRemovedSignalInfo+instance SignalInfo VolumeRemovedSignalInfo where+    type HaskellCallbackType VolumeRemovedSignalInfo = VolumeRemovedCallback+    connectSignal _ = connectVolumeRemoved++type instance SignalList Volume = VolumeSignalList+type VolumeSignalList = ('[ '("changed", VolumeChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("removed", VolumeRemovedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "g_volume_get_type"+    c_g_volume_get_type :: IO GType++type instance ParentTypes Volume = VolumeParentTypes+type VolumeParentTypes = '[GObject.Object]++instance GObject Volume where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_volume_get_type+    ++class GObject o => VolumeK o+instance (GObject o, IsDescendantOf Volume o) => VolumeK o++toVolume :: VolumeK o => o -> IO Volume+toVolume = unsafeCastTo Volume++-- method Volume::can_eject+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_volume_can_eject" g_volume_can_eject :: +    Ptr Volume ->                           -- _obj : TInterface "Gio" "Volume"+    IO CInt+++volumeCanEject ::+    (MonadIO m, VolumeK a) =>+    a ->                                    -- _obj+    m Bool+volumeCanEject _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_volume_can_eject _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Volume::can_mount+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_volume_can_mount" g_volume_can_mount :: +    Ptr Volume ->                           -- _obj : TInterface "Gio" "Volume"+    IO CInt+++volumeCanMount ::+    (MonadIO m, VolumeK a) =>+    a ->                                    -- _obj+    m Bool+volumeCanMount _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_volume_can_mount _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Volume::eject+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountUnmountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountUnmountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_volume_eject" g_volume_eject :: +    Ptr Volume ->                           -- _obj : TInterface "Gio" "Volume"+    CUInt ->                                -- flags : TInterface "Gio" "MountUnmountFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()++{-# DEPRECATED volumeEject ["(Since version 2.22)","Use g_volume_eject_with_operation() instead."]#-}+volumeEject ::+    (MonadIO m, VolumeK a, CancellableK b) =>+    a ->                                    -- _obj+    [MountUnmountFlags] ->                  -- flags+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+volumeEject _obj flags cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_volume_eject _obj' flags' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method Volume::eject_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_volume_eject_finish" g_volume_eject_finish :: +    Ptr Volume ->                           -- _obj : TInterface "Gio" "Volume"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt++{-# DEPRECATED volumeEjectFinish ["(Since version 2.22)","Use g_volume_eject_with_operation_finish() instead."]#-}+volumeEjectFinish ::+    (MonadIO m, VolumeK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+volumeEjectFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_volume_eject_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++-- method Volume::eject_with_operation+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountUnmountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mount_operation", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountUnmountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mount_operation", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_volume_eject_with_operation" g_volume_eject_with_operation :: +    Ptr Volume ->                           -- _obj : TInterface "Gio" "Volume"+    CUInt ->                                -- flags : TInterface "Gio" "MountUnmountFlags"+    Ptr MountOperation ->                   -- mount_operation : TInterface "Gio" "MountOperation"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++volumeEjectWithOperation ::+    (MonadIO m, VolumeK a, MountOperationK b, CancellableK c) =>+    a ->                                    -- _obj+    [MountUnmountFlags] ->                  -- flags+    Maybe (b) ->                            -- mount_operation+    Maybe (c) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+volumeEjectWithOperation _obj flags mount_operation cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    maybeMount_operation <- case mount_operation of+        Nothing -> return nullPtr+        Just jMount_operation -> do+            let jMount_operation' = unsafeManagedPtrCastPtr jMount_operation+            return jMount_operation'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_volume_eject_with_operation _obj' flags' maybeMount_operation maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust mount_operation touchManagedPtr+    whenJust cancellable touchManagedPtr+    return ()++-- method Volume::eject_with_operation_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_volume_eject_with_operation_finish" g_volume_eject_with_operation_finish :: +    Ptr Volume ->                           -- _obj : TInterface "Gio" "Volume"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++volumeEjectWithOperationFinish ::+    (MonadIO m, VolumeK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+volumeEjectWithOperationFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_volume_eject_with_operation_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++-- method Volume::enumerate_identifiers+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_volume_enumerate_identifiers" g_volume_enumerate_identifiers :: +    Ptr Volume ->                           -- _obj : TInterface "Gio" "Volume"+    IO (Ptr CString)+++volumeEnumerateIdentifiers ::+    (MonadIO m, VolumeK a) =>+    a ->                                    -- _obj+    m [T.Text]+volumeEnumerateIdentifiers _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_volume_enumerate_identifiers _obj'+    checkUnexpectedReturnNULL "g_volume_enumerate_identifiers" result+    result' <- unpackZeroTerminatedUTF8CArray result+    mapZeroTerminatedCArray freeMem result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method Volume::get_activation_root+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "File"+-- throws : False+-- Skip return : False++foreign import ccall "g_volume_get_activation_root" g_volume_get_activation_root :: +    Ptr Volume ->                           -- _obj : TInterface "Gio" "Volume"+    IO (Ptr File)+++volumeGetActivationRoot ::+    (MonadIO m, VolumeK a) =>+    a ->                                    -- _obj+    m File+volumeGetActivationRoot _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_volume_get_activation_root _obj'+    checkUnexpectedReturnNULL "g_volume_get_activation_root" result+    result' <- (wrapObject File) result+    touchManagedPtr _obj+    return result'++-- method Volume::get_drive+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Drive"+-- throws : False+-- Skip return : False++foreign import ccall "g_volume_get_drive" g_volume_get_drive :: +    Ptr Volume ->                           -- _obj : TInterface "Gio" "Volume"+    IO (Ptr Drive)+++volumeGetDrive ::+    (MonadIO m, VolumeK a) =>+    a ->                                    -- _obj+    m Drive+volumeGetDrive _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_volume_get_drive _obj'+    checkUnexpectedReturnNULL "g_volume_get_drive" result+    result' <- (wrapObject Drive) result+    touchManagedPtr _obj+    return result'++-- method Volume::get_icon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Icon"+-- throws : False+-- Skip return : False++foreign import ccall "g_volume_get_icon" g_volume_get_icon :: +    Ptr Volume ->                           -- _obj : TInterface "Gio" "Volume"+    IO (Ptr Icon)+++volumeGetIcon ::+    (MonadIO m, VolumeK a) =>+    a ->                                    -- _obj+    m Icon+volumeGetIcon _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_volume_get_icon _obj'+    checkUnexpectedReturnNULL "g_volume_get_icon" result+    result' <- (wrapObject Icon) result+    touchManagedPtr _obj+    return result'++-- method Volume::get_identifier+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "kind", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "kind", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_volume_get_identifier" g_volume_get_identifier :: +    Ptr Volume ->                           -- _obj : TInterface "Gio" "Volume"+    CString ->                              -- kind : TBasicType TUTF8+    IO CString+++volumeGetIdentifier ::+    (MonadIO m, VolumeK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- kind+    m T.Text+volumeGetIdentifier _obj kind = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    kind' <- textToCString kind+    result <- g_volume_get_identifier _obj' kind'+    checkUnexpectedReturnNULL "g_volume_get_identifier" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    freeMem kind'+    return result'++-- method Volume::get_mount+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Mount"+-- throws : False+-- Skip return : False++foreign import ccall "g_volume_get_mount" g_volume_get_mount :: +    Ptr Volume ->                           -- _obj : TInterface "Gio" "Volume"+    IO (Ptr Mount)+++volumeGetMount ::+    (MonadIO m, VolumeK a) =>+    a ->                                    -- _obj+    m Mount+volumeGetMount _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_volume_get_mount _obj'+    checkUnexpectedReturnNULL "g_volume_get_mount" result+    result' <- (wrapObject Mount) result+    touchManagedPtr _obj+    return result'++-- method Volume::get_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_volume_get_name" g_volume_get_name :: +    Ptr Volume ->                           -- _obj : TInterface "Gio" "Volume"+    IO CString+++volumeGetName ::+    (MonadIO m, VolumeK a) =>+    a ->                                    -- _obj+    m T.Text+volumeGetName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_volume_get_name _obj'+    checkUnexpectedReturnNULL "g_volume_get_name" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method Volume::get_sort_key+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_volume_get_sort_key" g_volume_get_sort_key :: +    Ptr Volume ->                           -- _obj : TInterface "Gio" "Volume"+    IO CString+++volumeGetSortKey ::+    (MonadIO m, VolumeK a) =>+    a ->                                    -- _obj+    m T.Text+volumeGetSortKey _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_volume_get_sort_key _obj'+    checkUnexpectedReturnNULL "g_volume_get_sort_key" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Volume::get_symbolic_icon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Icon"+-- throws : False+-- Skip return : False++foreign import ccall "g_volume_get_symbolic_icon" g_volume_get_symbolic_icon :: +    Ptr Volume ->                           -- _obj : TInterface "Gio" "Volume"+    IO (Ptr Icon)+++volumeGetSymbolicIcon ::+    (MonadIO m, VolumeK a) =>+    a ->                                    -- _obj+    m Icon+volumeGetSymbolicIcon _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_volume_get_symbolic_icon _obj'+    checkUnexpectedReturnNULL "g_volume_get_symbolic_icon" result+    result' <- (wrapObject Icon) result+    touchManagedPtr _obj+    return result'++-- method Volume::get_uuid+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_volume_get_uuid" g_volume_get_uuid :: +    Ptr Volume ->                           -- _obj : TInterface "Gio" "Volume"+    IO CString+++volumeGetUuid ::+    (MonadIO m, VolumeK a) =>+    a ->                                    -- _obj+    m T.Text+volumeGetUuid _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_volume_get_uuid _obj'+    checkUnexpectedReturnNULL "g_volume_get_uuid" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method Volume::mount+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountMountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mount_operation", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "MountMountFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mount_operation", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_volume_mount" g_volume_mount :: +    Ptr Volume ->                           -- _obj : TInterface "Gio" "Volume"+    CUInt ->                                -- flags : TInterface "Gio" "MountMountFlags"+    Ptr MountOperation ->                   -- mount_operation : TInterface "Gio" "MountOperation"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++volumeMount ::+    (MonadIO m, VolumeK a, MountOperationK b, CancellableK c) =>+    a ->                                    -- _obj+    [MountMountFlags] ->                    -- flags+    Maybe (b) ->                            -- mount_operation+    Maybe (c) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+volumeMount _obj flags mount_operation cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    maybeMount_operation <- case mount_operation of+        Nothing -> return nullPtr+        Just jMount_operation -> do+            let jMount_operation' = unsafeManagedPtrCastPtr jMount_operation+            return jMount_operation'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_volume_mount _obj' flags' maybeMount_operation maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust mount_operation touchManagedPtr+    whenJust cancellable touchManagedPtr+    return ()++-- method Volume::mount_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_volume_mount_finish" g_volume_mount_finish :: +    Ptr Volume ->                           -- _obj : TInterface "Gio" "Volume"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++volumeMountFinish ::+    (MonadIO m, VolumeK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+volumeMountFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_volume_mount_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++-- method Volume::should_automount+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Volume", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_volume_should_automount" g_volume_should_automount :: +    Ptr Volume ->                           -- _obj : TInterface "Gio" "Volume"+    IO CInt+++volumeShouldAutomount ::+    (MonadIO m, VolumeK a) =>+    a ->                                    -- _obj+    m Bool+volumeShouldAutomount _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_volume_should_automount _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++
+ GI/Gio/Interfaces/Volume.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gio.Interfaces.Volume where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Volume = Volume (ForeignPtr Volume)+data VolumeChangedSignalInfo+data VolumeRemovedSignalInfo+instance GObject Volume where+class GObject o => VolumeK o+instance (GObject o, IsDescendantOf Volume o) => VolumeK o
+ GI/Gio/Objects.hs view
@@ -0,0 +1,232 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects+    (     module GI.Gio.Objects.AppInfoMonitor    ,+    module GI.Gio.Objects.AppLaunchContext  ,+    module GI.Gio.Objects.Application       ,+    module GI.Gio.Objects.ApplicationCommandLine,+    module GI.Gio.Objects.BufferedInputStream,+    module GI.Gio.Objects.BufferedOutputStream,+    module GI.Gio.Objects.BytesIcon         ,+    module GI.Gio.Objects.Cancellable       ,+    module GI.Gio.Objects.CharsetConverter  ,+    module GI.Gio.Objects.ConverterInputStream,+    module GI.Gio.Objects.ConverterOutputStream,+    module GI.Gio.Objects.Credentials       ,+    module GI.Gio.Objects.DBusActionGroup   ,+    module GI.Gio.Objects.DBusAuthObserver  ,+    module GI.Gio.Objects.DBusConnection    ,+    module GI.Gio.Objects.DBusInterfaceSkeleton,+    module GI.Gio.Objects.DBusMenuModel     ,+    module GI.Gio.Objects.DBusMessage       ,+    module GI.Gio.Objects.DBusMethodInvocation,+    module GI.Gio.Objects.DBusObjectManagerClient,+    module GI.Gio.Objects.DBusObjectManagerServer,+    module GI.Gio.Objects.DBusObjectProxy   ,+    module GI.Gio.Objects.DBusObjectSkeleton,+    module GI.Gio.Objects.DBusProxy         ,+    module GI.Gio.Objects.DBusServer        ,+    module GI.Gio.Objects.DataInputStream   ,+    module GI.Gio.Objects.DataOutputStream  ,+    module GI.Gio.Objects.DesktopAppInfo    ,+    module GI.Gio.Objects.Emblem            ,+    module GI.Gio.Objects.EmblemedIcon      ,+    module GI.Gio.Objects.FileEnumerator    ,+    module GI.Gio.Objects.FileIOStream      ,+    module GI.Gio.Objects.FileIcon          ,+    module GI.Gio.Objects.FileInfo          ,+    module GI.Gio.Objects.FileInputStream   ,+    module GI.Gio.Objects.FileMonitor       ,+    module GI.Gio.Objects.FileOutputStream  ,+    module GI.Gio.Objects.FilenameCompleter ,+    module GI.Gio.Objects.FilterInputStream ,+    module GI.Gio.Objects.FilterOutputStream,+    module GI.Gio.Objects.IOStream          ,+    module GI.Gio.Objects.InetAddress       ,+    module GI.Gio.Objects.InetAddressMask   ,+    module GI.Gio.Objects.InetSocketAddress ,+    module GI.Gio.Objects.InputStream       ,+    module GI.Gio.Objects.ListStore         ,+    module GI.Gio.Objects.MemoryInputStream ,+    module GI.Gio.Objects.MemoryOutputStream,+    module GI.Gio.Objects.Menu              ,+    module GI.Gio.Objects.MenuAttributeIter ,+    module GI.Gio.Objects.MenuItem          ,+    module GI.Gio.Objects.MenuLinkIter      ,+    module GI.Gio.Objects.MenuModel         ,+    module GI.Gio.Objects.MountOperation    ,+    module GI.Gio.Objects.NativeVolumeMonitor,+    module GI.Gio.Objects.NetworkAddress    ,+    module GI.Gio.Objects.NetworkService    ,+    module GI.Gio.Objects.Notification      ,+    module GI.Gio.Objects.OutputStream      ,+    module GI.Gio.Objects.Permission        ,+    module GI.Gio.Objects.PropertyAction    ,+    module GI.Gio.Objects.ProxyAddress      ,+    module GI.Gio.Objects.ProxyAddressEnumerator,+    module GI.Gio.Objects.Resolver          ,+    module GI.Gio.Objects.Settings          ,+    module GI.Gio.Objects.SimpleAction      ,+    module GI.Gio.Objects.SimpleActionGroup ,+    module GI.Gio.Objects.SimpleAsyncResult ,+    module GI.Gio.Objects.SimpleIOStream    ,+    module GI.Gio.Objects.SimplePermission  ,+    module GI.Gio.Objects.SimpleProxyResolver,+    module GI.Gio.Objects.Socket            ,+    module GI.Gio.Objects.SocketAddress     ,+    module GI.Gio.Objects.SocketAddressEnumerator,+    module GI.Gio.Objects.SocketClient      ,+    module GI.Gio.Objects.SocketConnection  ,+    module GI.Gio.Objects.SocketControlMessage,+    module GI.Gio.Objects.SocketListener    ,+    module GI.Gio.Objects.SocketService     ,+    module GI.Gio.Objects.Subprocess        ,+    module GI.Gio.Objects.SubprocessLauncher,+    module GI.Gio.Objects.Task              ,+    module GI.Gio.Objects.TcpConnection     ,+    module GI.Gio.Objects.TcpWrapperConnection,+    module GI.Gio.Objects.TestDBus          ,+    module GI.Gio.Objects.ThemedIcon        ,+    module GI.Gio.Objects.ThreadedSocketService,+    module GI.Gio.Objects.TlsCertificate    ,+    module GI.Gio.Objects.TlsConnection     ,+    module GI.Gio.Objects.TlsDatabase       ,+    module GI.Gio.Objects.TlsInteraction    ,+    module GI.Gio.Objects.TlsPassword       ,+    module GI.Gio.Objects.UnixConnection    ,+    module GI.Gio.Objects.UnixCredentialsMessage,+    module GI.Gio.Objects.UnixFDList        ,+    module GI.Gio.Objects.UnixFDMessage     ,+    module GI.Gio.Objects.UnixInputStream   ,+    module GI.Gio.Objects.UnixMountMonitor  ,+    module GI.Gio.Objects.UnixOutputStream  ,+    module GI.Gio.Objects.UnixSocketAddress ,+    module GI.Gio.Objects.Vfs               ,+    module GI.Gio.Objects.VolumeMonitor     ,+    module GI.Gio.Objects.ZlibCompressor    ,+    module GI.Gio.Objects.ZlibDecompressor  ,+++    ) where++import GI.Gio.Objects.AppInfoMonitor+import GI.Gio.Objects.AppLaunchContext+import GI.Gio.Objects.Application+import GI.Gio.Objects.ApplicationCommandLine+import GI.Gio.Objects.BufferedInputStream+import GI.Gio.Objects.BufferedOutputStream+import GI.Gio.Objects.BytesIcon+import GI.Gio.Objects.Cancellable+import GI.Gio.Objects.CharsetConverter+import GI.Gio.Objects.ConverterInputStream+import GI.Gio.Objects.ConverterOutputStream+import GI.Gio.Objects.Credentials+import GI.Gio.Objects.DBusActionGroup+import GI.Gio.Objects.DBusAuthObserver+import GI.Gio.Objects.DBusConnection+import GI.Gio.Objects.DBusInterfaceSkeleton+import GI.Gio.Objects.DBusMenuModel+import GI.Gio.Objects.DBusMessage+import GI.Gio.Objects.DBusMethodInvocation+import GI.Gio.Objects.DBusObjectManagerClient+import GI.Gio.Objects.DBusObjectManagerServer+import GI.Gio.Objects.DBusObjectProxy+import GI.Gio.Objects.DBusObjectSkeleton+import GI.Gio.Objects.DBusProxy+import GI.Gio.Objects.DBusServer+import GI.Gio.Objects.DataInputStream+import GI.Gio.Objects.DataOutputStream+import GI.Gio.Objects.DesktopAppInfo+import GI.Gio.Objects.Emblem+import GI.Gio.Objects.EmblemedIcon+import GI.Gio.Objects.FileEnumerator+import GI.Gio.Objects.FileIOStream+import GI.Gio.Objects.FileIcon+import GI.Gio.Objects.FileInfo+import GI.Gio.Objects.FileInputStream+import GI.Gio.Objects.FileMonitor+import GI.Gio.Objects.FileOutputStream+import GI.Gio.Objects.FilenameCompleter+import GI.Gio.Objects.FilterInputStream+import GI.Gio.Objects.FilterOutputStream+import GI.Gio.Objects.IOStream+import GI.Gio.Objects.InetAddress+import GI.Gio.Objects.InetAddressMask+import GI.Gio.Objects.InetSocketAddress+import GI.Gio.Objects.InputStream+import GI.Gio.Objects.ListStore+import GI.Gio.Objects.MemoryInputStream+import GI.Gio.Objects.MemoryOutputStream+import GI.Gio.Objects.Menu+import GI.Gio.Objects.MenuAttributeIter+import GI.Gio.Objects.MenuItem+import GI.Gio.Objects.MenuLinkIter+import GI.Gio.Objects.MenuModel+import GI.Gio.Objects.MountOperation+import GI.Gio.Objects.NativeVolumeMonitor+import GI.Gio.Objects.NetworkAddress+import GI.Gio.Objects.NetworkService+import GI.Gio.Objects.Notification+import GI.Gio.Objects.OutputStream+import GI.Gio.Objects.Permission+import GI.Gio.Objects.PropertyAction+import GI.Gio.Objects.ProxyAddress+import GI.Gio.Objects.ProxyAddressEnumerator+import GI.Gio.Objects.Resolver+import GI.Gio.Objects.Settings+import GI.Gio.Objects.SimpleAction+import GI.Gio.Objects.SimpleActionGroup+import GI.Gio.Objects.SimpleAsyncResult+import GI.Gio.Objects.SimpleIOStream+import GI.Gio.Objects.SimplePermission+import GI.Gio.Objects.SimpleProxyResolver+import GI.Gio.Objects.Socket+import GI.Gio.Objects.SocketAddress+import GI.Gio.Objects.SocketAddressEnumerator+import GI.Gio.Objects.SocketClient+import GI.Gio.Objects.SocketConnection+import GI.Gio.Objects.SocketControlMessage+import GI.Gio.Objects.SocketListener+import GI.Gio.Objects.SocketService+import GI.Gio.Objects.Subprocess+import GI.Gio.Objects.SubprocessLauncher+import GI.Gio.Objects.Task+import GI.Gio.Objects.TcpConnection+import GI.Gio.Objects.TcpWrapperConnection+import GI.Gio.Objects.TestDBus+import GI.Gio.Objects.ThemedIcon+import GI.Gio.Objects.ThreadedSocketService+import GI.Gio.Objects.TlsCertificate+import GI.Gio.Objects.TlsConnection+import GI.Gio.Objects.TlsDatabase+import GI.Gio.Objects.TlsInteraction+import GI.Gio.Objects.TlsPassword+import GI.Gio.Objects.UnixConnection+import GI.Gio.Objects.UnixCredentialsMessage+import GI.Gio.Objects.UnixFDList+import GI.Gio.Objects.UnixFDMessage+import GI.Gio.Objects.UnixInputStream+import GI.Gio.Objects.UnixMountMonitor+import GI.Gio.Objects.UnixOutputStream+import GI.Gio.Objects.UnixSocketAddress+import GI.Gio.Objects.Vfs+import GI.Gio.Objects.VolumeMonitor+import GI.Gio.Objects.ZlibCompressor+import GI.Gio.Objects.ZlibDecompressor++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks++
+ GI/Gio/Objects/AppInfoMonitor.hs view
@@ -0,0 +1,145 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.AppInfoMonitor+    ( ++-- * Exported types+    AppInfoMonitor(..)                      ,+    AppInfoMonitorK                         ,+    toAppInfoMonitor                        ,+    noAppInfoMonitor                        ,+++ -- * Methods+-- ** appInfoMonitorGet+    appInfoMonitorGet                       ,+++++ -- * Signals+-- ** Changed+    AppInfoMonitorChangedCallback           ,+    AppInfoMonitorChangedCallbackC          ,+    AppInfoMonitorChangedSignalInfo         ,+    afterAppInfoMonitorChanged              ,+    appInfoMonitorChangedCallbackWrapper    ,+    appInfoMonitorChangedClosure            ,+    mkAppInfoMonitorChangedCallback         ,+    noAppInfoMonitorChangedCallback         ,+    onAppInfoMonitorChanged                 ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype AppInfoMonitor = AppInfoMonitor (ForeignPtr AppInfoMonitor)+foreign import ccall "g_app_info_monitor_get_type"+    c_g_app_info_monitor_get_type :: IO GType++type instance ParentTypes AppInfoMonitor = AppInfoMonitorParentTypes+type AppInfoMonitorParentTypes = '[GObject.Object]++instance GObject AppInfoMonitor where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_app_info_monitor_get_type+    ++class GObject o => AppInfoMonitorK o+instance (GObject o, IsDescendantOf AppInfoMonitor o) => AppInfoMonitorK o++toAppInfoMonitor :: AppInfoMonitorK o => o -> IO AppInfoMonitor+toAppInfoMonitor = unsafeCastTo AppInfoMonitor++noAppInfoMonitor :: Maybe AppInfoMonitor+noAppInfoMonitor = Nothing++-- signal AppInfoMonitor::changed+type AppInfoMonitorChangedCallback =+    IO ()++noAppInfoMonitorChangedCallback :: Maybe AppInfoMonitorChangedCallback+noAppInfoMonitorChangedCallback = Nothing++type AppInfoMonitorChangedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkAppInfoMonitorChangedCallback :: AppInfoMonitorChangedCallbackC -> IO (FunPtr AppInfoMonitorChangedCallbackC)++appInfoMonitorChangedClosure :: AppInfoMonitorChangedCallback -> IO Closure+appInfoMonitorChangedClosure cb = newCClosure =<< mkAppInfoMonitorChangedCallback wrapped+    where wrapped = appInfoMonitorChangedCallbackWrapper cb++appInfoMonitorChangedCallbackWrapper ::+    AppInfoMonitorChangedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+appInfoMonitorChangedCallbackWrapper _cb _ _ = do+    _cb ++onAppInfoMonitorChanged :: (GObject a, MonadIO m) => a -> AppInfoMonitorChangedCallback -> m SignalHandlerId+onAppInfoMonitorChanged obj cb = liftIO $ connectAppInfoMonitorChanged obj cb SignalConnectBefore+afterAppInfoMonitorChanged :: (GObject a, MonadIO m) => a -> AppInfoMonitorChangedCallback -> m SignalHandlerId+afterAppInfoMonitorChanged obj cb = connectAppInfoMonitorChanged obj cb SignalConnectAfter++connectAppInfoMonitorChanged :: (GObject a, MonadIO m) =>+                                a -> AppInfoMonitorChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectAppInfoMonitorChanged obj cb after = liftIO $ do+    cb' <- mkAppInfoMonitorChangedCallback (appInfoMonitorChangedCallbackWrapper cb)+    connectSignalFunPtr obj "changed" cb' after++type instance AttributeList AppInfoMonitor = AppInfoMonitorAttributeList+type AppInfoMonitorAttributeList = ('[ ] :: [(Symbol, *)])++data AppInfoMonitorChangedSignalInfo+instance SignalInfo AppInfoMonitorChangedSignalInfo where+    type HaskellCallbackType AppInfoMonitorChangedSignalInfo = AppInfoMonitorChangedCallback+    connectSignal _ = connectAppInfoMonitorChanged++type instance SignalList AppInfoMonitor = AppInfoMonitorSignalList+type AppInfoMonitorSignalList = ('[ '("changed", AppInfoMonitorChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method AppInfoMonitor::get+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gio" "AppInfoMonitor"+-- throws : False+-- Skip return : False++foreign import ccall "g_app_info_monitor_get" g_app_info_monitor_get :: +    IO (Ptr AppInfoMonitor)+++appInfoMonitorGet ::+    (MonadIO m) =>+    m AppInfoMonitor+appInfoMonitorGet  = liftIO $ do+    result <- g_app_info_monitor_get+    checkUnexpectedReturnNULL "g_app_info_monitor_get" result+    result' <- (wrapObject AppInfoMonitor) result+    return result'++
+ GI/Gio/Objects/AppInfoMonitor.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gio.Objects.AppInfoMonitor where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype AppInfoMonitor = AppInfoMonitor (ForeignPtr AppInfoMonitor)+instance GObject AppInfoMonitor where+class GObject o => AppInfoMonitorK o+instance (GObject o, IsDescendantOf AppInfoMonitor o) => AppInfoMonitorK o+data AppInfoMonitorChangedSignalInfo
+ GI/Gio/Objects/AppLaunchContext.hs view
@@ -0,0 +1,426 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.AppLaunchContext+    ( ++-- * Exported types+    AppLaunchContext(..)                    ,+    AppLaunchContextK                       ,+    toAppLaunchContext                      ,+    noAppLaunchContext                      ,+++ -- * Methods+-- ** appLaunchContextGetDisplay+    appLaunchContextGetDisplay              ,+++-- ** appLaunchContextGetEnvironment+    appLaunchContextGetEnvironment          ,+++-- ** appLaunchContextGetStartupNotifyId+    appLaunchContextGetStartupNotifyId      ,+++-- ** appLaunchContextLaunchFailed+    appLaunchContextLaunchFailed            ,+++-- ** appLaunchContextNew+    appLaunchContextNew                     ,+++-- ** appLaunchContextSetenv+    appLaunchContextSetenv                  ,+++-- ** appLaunchContextUnsetenv+    appLaunchContextUnsetenv                ,+++++ -- * Signals+-- ** LaunchFailed+    AppLaunchContextLaunchFailedCallback    ,+    AppLaunchContextLaunchFailedCallbackC   ,+    AppLaunchContextLaunchFailedSignalInfo  ,+    afterAppLaunchContextLaunchFailed       ,+    appLaunchContextLaunchFailedCallbackWrapper,+    appLaunchContextLaunchFailedClosure     ,+    mkAppLaunchContextLaunchFailedCallback  ,+    noAppLaunchContextLaunchFailedCallback  ,+    onAppLaunchContextLaunchFailed          ,+++-- ** Launched+    AppLaunchContextLaunchedCallback        ,+    AppLaunchContextLaunchedCallbackC       ,+    AppLaunchContextLaunchedSignalInfo      ,+    afterAppLaunchContextLaunched           ,+    appLaunchContextLaunchedCallbackWrapper ,+    appLaunchContextLaunchedClosure         ,+    mkAppLaunchContextLaunchedCallback      ,+    noAppLaunchContextLaunchedCallback      ,+    onAppLaunchContextLaunched              ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype AppLaunchContext = AppLaunchContext (ForeignPtr AppLaunchContext)+foreign import ccall "g_app_launch_context_get_type"+    c_g_app_launch_context_get_type :: IO GType++type instance ParentTypes AppLaunchContext = AppLaunchContextParentTypes+type AppLaunchContextParentTypes = '[GObject.Object]++instance GObject AppLaunchContext where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_app_launch_context_get_type+    ++class GObject o => AppLaunchContextK o+instance (GObject o, IsDescendantOf AppLaunchContext o) => AppLaunchContextK o++toAppLaunchContext :: AppLaunchContextK o => o -> IO AppLaunchContext+toAppLaunchContext = unsafeCastTo AppLaunchContext++noAppLaunchContext :: Maybe AppLaunchContext+noAppLaunchContext = Nothing++-- signal AppLaunchContext::launch-failed+type AppLaunchContextLaunchFailedCallback =+    T.Text ->+    IO ()++noAppLaunchContextLaunchFailedCallback :: Maybe AppLaunchContextLaunchFailedCallback+noAppLaunchContextLaunchFailedCallback = Nothing++type AppLaunchContextLaunchFailedCallbackC =+    Ptr () ->                               -- object+    CString ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkAppLaunchContextLaunchFailedCallback :: AppLaunchContextLaunchFailedCallbackC -> IO (FunPtr AppLaunchContextLaunchFailedCallbackC)++appLaunchContextLaunchFailedClosure :: AppLaunchContextLaunchFailedCallback -> IO Closure+appLaunchContextLaunchFailedClosure cb = newCClosure =<< mkAppLaunchContextLaunchFailedCallback wrapped+    where wrapped = appLaunchContextLaunchFailedCallbackWrapper cb++appLaunchContextLaunchFailedCallbackWrapper ::+    AppLaunchContextLaunchFailedCallback ->+    Ptr () ->+    CString ->+    Ptr () ->+    IO ()+appLaunchContextLaunchFailedCallbackWrapper _cb _ startup_notify_id _ = do+    startup_notify_id' <- cstringToText startup_notify_id+    _cb  startup_notify_id'++onAppLaunchContextLaunchFailed :: (GObject a, MonadIO m) => a -> AppLaunchContextLaunchFailedCallback -> m SignalHandlerId+onAppLaunchContextLaunchFailed obj cb = liftIO $ connectAppLaunchContextLaunchFailed obj cb SignalConnectBefore+afterAppLaunchContextLaunchFailed :: (GObject a, MonadIO m) => a -> AppLaunchContextLaunchFailedCallback -> m SignalHandlerId+afterAppLaunchContextLaunchFailed obj cb = connectAppLaunchContextLaunchFailed obj cb SignalConnectAfter++connectAppLaunchContextLaunchFailed :: (GObject a, MonadIO m) =>+                                       a -> AppLaunchContextLaunchFailedCallback -> SignalConnectMode -> m SignalHandlerId+connectAppLaunchContextLaunchFailed obj cb after = liftIO $ do+    cb' <- mkAppLaunchContextLaunchFailedCallback (appLaunchContextLaunchFailedCallbackWrapper cb)+    connectSignalFunPtr obj "launch-failed" cb' after++-- signal AppLaunchContext::launched+type AppLaunchContextLaunchedCallback =+    AppInfo ->+    GVariant ->+    IO ()++noAppLaunchContextLaunchedCallback :: Maybe AppLaunchContextLaunchedCallback+noAppLaunchContextLaunchedCallback = Nothing++type AppLaunchContextLaunchedCallbackC =+    Ptr () ->                               -- object+    Ptr AppInfo ->+    Ptr GVariant ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkAppLaunchContextLaunchedCallback :: AppLaunchContextLaunchedCallbackC -> IO (FunPtr AppLaunchContextLaunchedCallbackC)++appLaunchContextLaunchedClosure :: AppLaunchContextLaunchedCallback -> IO Closure+appLaunchContextLaunchedClosure cb = newCClosure =<< mkAppLaunchContextLaunchedCallback wrapped+    where wrapped = appLaunchContextLaunchedCallbackWrapper cb++appLaunchContextLaunchedCallbackWrapper ::+    AppLaunchContextLaunchedCallback ->+    Ptr () ->+    Ptr AppInfo ->+    Ptr GVariant ->+    Ptr () ->+    IO ()+appLaunchContextLaunchedCallbackWrapper _cb _ info platform_data _ = do+    info' <- (newObject AppInfo) info+    platform_data' <- newGVariantFromPtr platform_data+    _cb  info' platform_data'++onAppLaunchContextLaunched :: (GObject a, MonadIO m) => a -> AppLaunchContextLaunchedCallback -> m SignalHandlerId+onAppLaunchContextLaunched obj cb = liftIO $ connectAppLaunchContextLaunched obj cb SignalConnectBefore+afterAppLaunchContextLaunched :: (GObject a, MonadIO m) => a -> AppLaunchContextLaunchedCallback -> m SignalHandlerId+afterAppLaunchContextLaunched obj cb = connectAppLaunchContextLaunched obj cb SignalConnectAfter++connectAppLaunchContextLaunched :: (GObject a, MonadIO m) =>+                                   a -> AppLaunchContextLaunchedCallback -> SignalConnectMode -> m SignalHandlerId+connectAppLaunchContextLaunched obj cb after = liftIO $ do+    cb' <- mkAppLaunchContextLaunchedCallback (appLaunchContextLaunchedCallbackWrapper cb)+    connectSignalFunPtr obj "launched" cb' after++type instance AttributeList AppLaunchContext = AppLaunchContextAttributeList+type AppLaunchContextAttributeList = ('[ ] :: [(Symbol, *)])++data AppLaunchContextLaunchFailedSignalInfo+instance SignalInfo AppLaunchContextLaunchFailedSignalInfo where+    type HaskellCallbackType AppLaunchContextLaunchFailedSignalInfo = AppLaunchContextLaunchFailedCallback+    connectSignal _ = connectAppLaunchContextLaunchFailed++data AppLaunchContextLaunchedSignalInfo+instance SignalInfo AppLaunchContextLaunchedSignalInfo where+    type HaskellCallbackType AppLaunchContextLaunchedSignalInfo = AppLaunchContextLaunchedCallback+    connectSignal _ = connectAppLaunchContextLaunched++type instance SignalList AppLaunchContext = AppLaunchContextSignalList+type AppLaunchContextSignalList = ('[ '("launch-failed", AppLaunchContextLaunchFailedSignalInfo), '("launched", AppLaunchContextLaunchedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method AppLaunchContext::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gio" "AppLaunchContext"+-- throws : False+-- Skip return : False++foreign import ccall "g_app_launch_context_new" g_app_launch_context_new :: +    IO (Ptr AppLaunchContext)+++appLaunchContextNew ::+    (MonadIO m) =>+    m AppLaunchContext+appLaunchContextNew  = liftIO $ do+    result <- g_app_launch_context_new+    checkUnexpectedReturnNULL "g_app_launch_context_new" result+    result' <- (wrapObject AppLaunchContext) result+    return result'++-- method AppLaunchContext::get_display+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AppLaunchContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "info", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "files", argType = TGList (TInterface "Gio" "File"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AppLaunchContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "info", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "files", argType = TGList (TInterface "Gio" "File"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_app_launch_context_get_display" g_app_launch_context_get_display :: +    Ptr AppLaunchContext ->                 -- _obj : TInterface "Gio" "AppLaunchContext"+    Ptr AppInfo ->                          -- info : TInterface "Gio" "AppInfo"+    Ptr (GList (Ptr File)) ->               -- files : TGList (TInterface "Gio" "File")+    IO CString+++appLaunchContextGetDisplay ::+    (MonadIO m, AppLaunchContextK a, AppInfoK b, FileK c) =>+    a ->                                    -- _obj+    b ->                                    -- info+    [c] ->                                  -- files+    m T.Text+appLaunchContextGetDisplay _obj info files = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let info' = unsafeManagedPtrCastPtr info+    let files' = map unsafeManagedPtrCastPtr files+    files'' <- packGList files'+    result <- g_app_launch_context_get_display _obj' info' files''+    checkUnexpectedReturnNULL "g_app_launch_context_get_display" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    touchManagedPtr info+    mapM_ touchManagedPtr files+    g_list_free files''+    return result'++-- method AppLaunchContext::get_environment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AppLaunchContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AppLaunchContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_app_launch_context_get_environment" g_app_launch_context_get_environment :: +    Ptr AppLaunchContext ->                 -- _obj : TInterface "Gio" "AppLaunchContext"+    IO (Ptr CString)+++appLaunchContextGetEnvironment ::+    (MonadIO m, AppLaunchContextK a) =>+    a ->                                    -- _obj+    m [T.Text]+appLaunchContextGetEnvironment _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_app_launch_context_get_environment _obj'+    checkUnexpectedReturnNULL "g_app_launch_context_get_environment" result+    result' <- unpackZeroTerminatedUTF8CArray result+    mapZeroTerminatedCArray freeMem result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method AppLaunchContext::get_startup_notify_id+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AppLaunchContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "info", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "files", argType = TGList (TInterface "Gio" "File"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AppLaunchContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "info", argType = TInterface "Gio" "AppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "files", argType = TGList (TInterface "Gio" "File"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_app_launch_context_get_startup_notify_id" g_app_launch_context_get_startup_notify_id :: +    Ptr AppLaunchContext ->                 -- _obj : TInterface "Gio" "AppLaunchContext"+    Ptr AppInfo ->                          -- info : TInterface "Gio" "AppInfo"+    Ptr (GList (Ptr File)) ->               -- files : TGList (TInterface "Gio" "File")+    IO CString+++appLaunchContextGetStartupNotifyId ::+    (MonadIO m, AppLaunchContextK a, AppInfoK b, FileK c) =>+    a ->                                    -- _obj+    b ->                                    -- info+    [c] ->                                  -- files+    m T.Text+appLaunchContextGetStartupNotifyId _obj info files = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let info' = unsafeManagedPtrCastPtr info+    let files' = map unsafeManagedPtrCastPtr files+    files'' <- packGList files'+    result <- g_app_launch_context_get_startup_notify_id _obj' info' files''+    checkUnexpectedReturnNULL "g_app_launch_context_get_startup_notify_id" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    touchManagedPtr info+    mapM_ touchManagedPtr files+    g_list_free files''+    return result'++-- method AppLaunchContext::launch_failed+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AppLaunchContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "startup_notify_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AppLaunchContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "startup_notify_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_app_launch_context_launch_failed" g_app_launch_context_launch_failed :: +    Ptr AppLaunchContext ->                 -- _obj : TInterface "Gio" "AppLaunchContext"+    CString ->                              -- startup_notify_id : TBasicType TUTF8+    IO ()+++appLaunchContextLaunchFailed ::+    (MonadIO m, AppLaunchContextK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- startup_notify_id+    m ()+appLaunchContextLaunchFailed _obj startup_notify_id = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    startup_notify_id' <- textToCString startup_notify_id+    g_app_launch_context_launch_failed _obj' startup_notify_id'+    touchManagedPtr _obj+    freeMem startup_notify_id'+    return ()++-- method AppLaunchContext::setenv+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AppLaunchContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "variable", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AppLaunchContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "variable", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_app_launch_context_setenv" g_app_launch_context_setenv :: +    Ptr AppLaunchContext ->                 -- _obj : TInterface "Gio" "AppLaunchContext"+    CString ->                              -- variable : TBasicType TUTF8+    CString ->                              -- value : TBasicType TUTF8+    IO ()+++appLaunchContextSetenv ::+    (MonadIO m, AppLaunchContextK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- variable+    T.Text ->                               -- value+    m ()+appLaunchContextSetenv _obj variable value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    variable' <- textToCString variable+    value' <- textToCString value+    g_app_launch_context_setenv _obj' variable' value'+    touchManagedPtr _obj+    freeMem variable'+    freeMem value'+    return ()++-- method AppLaunchContext::unsetenv+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "AppLaunchContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "variable", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "AppLaunchContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "variable", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_app_launch_context_unsetenv" g_app_launch_context_unsetenv :: +    Ptr AppLaunchContext ->                 -- _obj : TInterface "Gio" "AppLaunchContext"+    CString ->                              -- variable : TBasicType TUTF8+    IO ()+++appLaunchContextUnsetenv ::+    (MonadIO m, AppLaunchContextK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- variable+    m ()+appLaunchContextUnsetenv _obj variable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    variable' <- textToCString variable+    g_app_launch_context_unsetenv _obj' variable'+    touchManagedPtr _obj+    freeMem variable'+    return ()++
+ GI/Gio/Objects/AppLaunchContext.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gio.Objects.AppLaunchContext where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype AppLaunchContext = AppLaunchContext (ForeignPtr AppLaunchContext)+instance GObject AppLaunchContext where+class GObject o => AppLaunchContextK o+instance (GObject o, IsDescendantOf AppLaunchContext o) => AppLaunchContextK o+data AppLaunchContextLaunchFailedSignalInfo+data AppLaunchContextLaunchedSignalInfo
+ GI/Gio/Objects/Application.hs view
@@ -0,0 +1,1744 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.Application+    ( ++-- * Exported types+    Application(..)                         ,+    ApplicationK                            ,+    toApplication                           ,+    noApplication                           ,+++ -- * Methods+-- ** applicationActivate+    applicationActivate                     ,+++-- ** applicationAddMainOption+    applicationAddMainOption                ,+++-- ** applicationAddMainOptionEntries+    applicationAddMainOptionEntries         ,+++-- ** applicationAddOptionGroup+    applicationAddOptionGroup               ,+++-- ** applicationBindBusyProperty+    applicationBindBusyProperty             ,+++-- ** applicationGetApplicationId+    applicationGetApplicationId             ,+++-- ** applicationGetDbusConnection+    applicationGetDbusConnection            ,+++-- ** applicationGetDbusObjectPath+    applicationGetDbusObjectPath            ,+++-- ** applicationGetDefault+    applicationGetDefault                   ,+++-- ** applicationGetFlags+    applicationGetFlags                     ,+++-- ** applicationGetInactivityTimeout+    applicationGetInactivityTimeout         ,+++-- ** applicationGetIsBusy+    applicationGetIsBusy                    ,+++-- ** applicationGetIsRegistered+    applicationGetIsRegistered              ,+++-- ** applicationGetIsRemote+    applicationGetIsRemote                  ,+++-- ** applicationGetResourceBasePath+    applicationGetResourceBasePath          ,+++-- ** applicationHold+    applicationHold                         ,+++-- ** applicationIdIsValid+    applicationIdIsValid                    ,+++-- ** applicationMarkBusy+    applicationMarkBusy                     ,+++-- ** applicationNew+    applicationNew                          ,+++-- ** applicationOpen+    applicationOpen                         ,+++-- ** applicationQuit+    applicationQuit                         ,+++-- ** applicationRegister+    applicationRegister                     ,+++-- ** applicationRelease+    applicationRelease                      ,+++-- ** applicationRun+    applicationRun                          ,+++-- ** applicationSendNotification+    applicationSendNotification             ,+++-- ** applicationSetActionGroup+    applicationSetActionGroup               ,+++-- ** applicationSetApplicationId+    applicationSetApplicationId             ,+++-- ** applicationSetDefault+    applicationSetDefault                   ,+++-- ** applicationSetFlags+    applicationSetFlags                     ,+++-- ** applicationSetInactivityTimeout+    applicationSetInactivityTimeout         ,+++-- ** applicationSetResourceBasePath+    applicationSetResourceBasePath          ,+++-- ** applicationUnbindBusyProperty+    applicationUnbindBusyProperty           ,+++-- ** applicationUnmarkBusy+    applicationUnmarkBusy                   ,+++-- ** applicationWithdrawNotification+    applicationWithdrawNotification         ,+++++ -- * Properties+-- ** ActionGroup+    ApplicationActionGroupPropertyInfo      ,+    constructApplicationActionGroup         ,+    setApplicationActionGroup               ,+++-- ** ApplicationId+    ApplicationApplicationIdPropertyInfo    ,+    constructApplicationApplicationId       ,+    getApplicationApplicationId             ,+    setApplicationApplicationId             ,+++-- ** Flags+    ApplicationFlagsPropertyInfo            ,+    constructApplicationFlags               ,+    getApplicationFlags                     ,+    setApplicationFlags                     ,+++-- ** InactivityTimeout+    ApplicationInactivityTimeoutPropertyInfo,+    constructApplicationInactivityTimeout   ,+    getApplicationInactivityTimeout         ,+    setApplicationInactivityTimeout         ,+++-- ** IsBusy+    ApplicationIsBusyPropertyInfo           ,+    getApplicationIsBusy                    ,+++-- ** IsRegistered+    ApplicationIsRegisteredPropertyInfo     ,+    getApplicationIsRegistered              ,+++-- ** IsRemote+    ApplicationIsRemotePropertyInfo         ,+    getApplicationIsRemote                  ,+++-- ** ResourceBasePath+    ApplicationResourceBasePathPropertyInfo ,+    constructApplicationResourceBasePath    ,+    getApplicationResourceBasePath          ,+    setApplicationResourceBasePath          ,+++++ -- * Signals+-- ** Activate+    ApplicationActivateCallback             ,+    ApplicationActivateCallbackC            ,+    ApplicationActivateSignalInfo           ,+    afterApplicationActivate                ,+    applicationActivateCallbackWrapper      ,+    applicationActivateClosure              ,+    mkApplicationActivateCallback           ,+    noApplicationActivateCallback           ,+    onApplicationActivate                   ,+++-- ** CommandLine+    ApplicationCommandLineCallback          ,+    ApplicationCommandLineCallbackC         ,+    ApplicationCommandLineSignalInfo        ,+    afterApplicationCommandLine             ,+    applicationCommandLineCallbackWrapper   ,+    applicationCommandLineClosure           ,+    mkApplicationCommandLineCallback        ,+    noApplicationCommandLineCallback        ,+    onApplicationCommandLine                ,+++-- ** HandleLocalOptions+    ApplicationHandleLocalOptionsCallback   ,+    ApplicationHandleLocalOptionsCallbackC  ,+    ApplicationHandleLocalOptionsSignalInfo ,+    afterApplicationHandleLocalOptions      ,+    applicationHandleLocalOptionsCallbackWrapper,+    applicationHandleLocalOptionsClosure    ,+    mkApplicationHandleLocalOptionsCallback ,+    noApplicationHandleLocalOptionsCallback ,+    onApplicationHandleLocalOptions         ,+++-- ** Open+    ApplicationOpenCallback                 ,+    ApplicationOpenCallbackC                ,+    ApplicationOpenSignalInfo               ,+    afterApplicationOpen                    ,+    applicationOpenCallbackWrapper          ,+    applicationOpenClosure                  ,+    mkApplicationOpenCallback               ,+    noApplicationOpenCallback               ,+    onApplicationOpen                       ,+++-- ** Shutdown+    ApplicationShutdownCallback             ,+    ApplicationShutdownCallbackC            ,+    ApplicationShutdownSignalInfo           ,+    afterApplicationShutdown                ,+    applicationShutdownCallbackWrapper      ,+    applicationShutdownClosure              ,+    mkApplicationShutdownCallback           ,+    noApplicationShutdownCallback           ,+    onApplicationShutdown                   ,+++-- ** Startup+    ApplicationStartupCallback              ,+    ApplicationStartupCallbackC             ,+    ApplicationStartupSignalInfo            ,+    afterApplicationStartup                 ,+    applicationStartupCallbackWrapper       ,+    applicationStartupClosure               ,+    mkApplicationStartupCallback            ,+    noApplicationStartupCallback            ,+    onApplicationStartup                    ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype Application = Application (ForeignPtr Application)+foreign import ccall "g_application_get_type"+    c_g_application_get_type :: IO GType++type instance ParentTypes Application = ApplicationParentTypes+type ApplicationParentTypes = '[GObject.Object, ActionGroup, ActionMap]++instance GObject Application where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_application_get_type+    ++class GObject o => ApplicationK o+instance (GObject o, IsDescendantOf Application o) => ApplicationK o++toApplication :: ApplicationK o => o -> IO Application+toApplication = unsafeCastTo Application++noApplication :: Maybe Application+noApplication = Nothing++-- signal Application::activate+type ApplicationActivateCallback =+    IO ()++noApplicationActivateCallback :: Maybe ApplicationActivateCallback+noApplicationActivateCallback = Nothing++type ApplicationActivateCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkApplicationActivateCallback :: ApplicationActivateCallbackC -> IO (FunPtr ApplicationActivateCallbackC)++applicationActivateClosure :: ApplicationActivateCallback -> IO Closure+applicationActivateClosure cb = newCClosure =<< mkApplicationActivateCallback wrapped+    where wrapped = applicationActivateCallbackWrapper cb++applicationActivateCallbackWrapper ::+    ApplicationActivateCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+applicationActivateCallbackWrapper _cb _ _ = do+    _cb ++onApplicationActivate :: (GObject a, MonadIO m) => a -> ApplicationActivateCallback -> m SignalHandlerId+onApplicationActivate obj cb = liftIO $ connectApplicationActivate obj cb SignalConnectBefore+afterApplicationActivate :: (GObject a, MonadIO m) => a -> ApplicationActivateCallback -> m SignalHandlerId+afterApplicationActivate obj cb = connectApplicationActivate obj cb SignalConnectAfter++connectApplicationActivate :: (GObject a, MonadIO m) =>+                              a -> ApplicationActivateCallback -> SignalConnectMode -> m SignalHandlerId+connectApplicationActivate obj cb after = liftIO $ do+    cb' <- mkApplicationActivateCallback (applicationActivateCallbackWrapper cb)+    connectSignalFunPtr obj "activate" cb' after++-- signal Application::command-line+type ApplicationCommandLineCallback =+    ApplicationCommandLine ->+    IO Int32++noApplicationCommandLineCallback :: Maybe ApplicationCommandLineCallback+noApplicationCommandLineCallback = Nothing++type ApplicationCommandLineCallbackC =+    Ptr () ->                               -- object+    Ptr ApplicationCommandLine ->+    Ptr () ->                               -- user_data+    IO Int32++foreign import ccall "wrapper"+    mkApplicationCommandLineCallback :: ApplicationCommandLineCallbackC -> IO (FunPtr ApplicationCommandLineCallbackC)++applicationCommandLineClosure :: ApplicationCommandLineCallback -> IO Closure+applicationCommandLineClosure cb = newCClosure =<< mkApplicationCommandLineCallback wrapped+    where wrapped = applicationCommandLineCallbackWrapper cb++applicationCommandLineCallbackWrapper ::+    ApplicationCommandLineCallback ->+    Ptr () ->+    Ptr ApplicationCommandLine ->+    Ptr () ->+    IO Int32+applicationCommandLineCallbackWrapper _cb _ command_line _ = do+    command_line' <- (newObject ApplicationCommandLine) command_line+    result <- _cb  command_line'+    return result++onApplicationCommandLine :: (GObject a, MonadIO m) => a -> ApplicationCommandLineCallback -> m SignalHandlerId+onApplicationCommandLine obj cb = liftIO $ connectApplicationCommandLine obj cb SignalConnectBefore+afterApplicationCommandLine :: (GObject a, MonadIO m) => a -> ApplicationCommandLineCallback -> m SignalHandlerId+afterApplicationCommandLine obj cb = connectApplicationCommandLine obj cb SignalConnectAfter++connectApplicationCommandLine :: (GObject a, MonadIO m) =>+                                 a -> ApplicationCommandLineCallback -> SignalConnectMode -> m SignalHandlerId+connectApplicationCommandLine obj cb after = liftIO $ do+    cb' <- mkApplicationCommandLineCallback (applicationCommandLineCallbackWrapper cb)+    connectSignalFunPtr obj "command-line" cb' after++-- signal Application::handle-local-options+type ApplicationHandleLocalOptionsCallback =+    GLib.VariantDict ->+    IO Int32++noApplicationHandleLocalOptionsCallback :: Maybe ApplicationHandleLocalOptionsCallback+noApplicationHandleLocalOptionsCallback = Nothing++type ApplicationHandleLocalOptionsCallbackC =+    Ptr () ->                               -- object+    Ptr GLib.VariantDict ->+    Ptr () ->                               -- user_data+    IO Int32++foreign import ccall "wrapper"+    mkApplicationHandleLocalOptionsCallback :: ApplicationHandleLocalOptionsCallbackC -> IO (FunPtr ApplicationHandleLocalOptionsCallbackC)++applicationHandleLocalOptionsClosure :: ApplicationHandleLocalOptionsCallback -> IO Closure+applicationHandleLocalOptionsClosure cb = newCClosure =<< mkApplicationHandleLocalOptionsCallback wrapped+    where wrapped = applicationHandleLocalOptionsCallbackWrapper cb++applicationHandleLocalOptionsCallbackWrapper ::+    ApplicationHandleLocalOptionsCallback ->+    Ptr () ->+    Ptr GLib.VariantDict ->+    Ptr () ->+    IO Int32+applicationHandleLocalOptionsCallbackWrapper _cb _ options _ = do+    options' <- (newBoxed GLib.VariantDict) options+    result <- _cb  options'+    return result++onApplicationHandleLocalOptions :: (GObject a, MonadIO m) => a -> ApplicationHandleLocalOptionsCallback -> m SignalHandlerId+onApplicationHandleLocalOptions obj cb = liftIO $ connectApplicationHandleLocalOptions obj cb SignalConnectBefore+afterApplicationHandleLocalOptions :: (GObject a, MonadIO m) => a -> ApplicationHandleLocalOptionsCallback -> m SignalHandlerId+afterApplicationHandleLocalOptions obj cb = connectApplicationHandleLocalOptions obj cb SignalConnectAfter++connectApplicationHandleLocalOptions :: (GObject a, MonadIO m) =>+                                        a -> ApplicationHandleLocalOptionsCallback -> SignalConnectMode -> m SignalHandlerId+connectApplicationHandleLocalOptions obj cb after = liftIO $ do+    cb' <- mkApplicationHandleLocalOptionsCallback (applicationHandleLocalOptionsCallbackWrapper cb)+    connectSignalFunPtr obj "handle-local-options" cb' after++-- signal Application::open+type ApplicationOpenCallback =+    [File] ->+    T.Text ->+    IO ()++noApplicationOpenCallback :: Maybe ApplicationOpenCallback+noApplicationOpenCallback = Nothing++type ApplicationOpenCallbackC =+    Ptr () ->                               -- object+    Ptr (Ptr File) ->+    Int32 ->+    CString ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkApplicationOpenCallback :: ApplicationOpenCallbackC -> IO (FunPtr ApplicationOpenCallbackC)++applicationOpenClosure :: ApplicationOpenCallback -> IO Closure+applicationOpenClosure cb = newCClosure =<< mkApplicationOpenCallback wrapped+    where wrapped = applicationOpenCallbackWrapper cb++applicationOpenCallbackWrapper ::+    ApplicationOpenCallback ->+    Ptr () ->+    Ptr (Ptr File) ->+    Int32 ->+    CString ->+    Ptr () ->+    IO ()+applicationOpenCallbackWrapper _cb _ files n_files hint _ = do+    files' <- (unpackPtrArrayWithLength n_files) files+    files'' <- mapM (newObject File) files'+    hint' <- cstringToText hint+    _cb  files'' hint'++onApplicationOpen :: (GObject a, MonadIO m) => a -> ApplicationOpenCallback -> m SignalHandlerId+onApplicationOpen obj cb = liftIO $ connectApplicationOpen obj cb SignalConnectBefore+afterApplicationOpen :: (GObject a, MonadIO m) => a -> ApplicationOpenCallback -> m SignalHandlerId+afterApplicationOpen obj cb = connectApplicationOpen obj cb SignalConnectAfter++connectApplicationOpen :: (GObject a, MonadIO m) =>+                          a -> ApplicationOpenCallback -> SignalConnectMode -> m SignalHandlerId+connectApplicationOpen obj cb after = liftIO $ do+    cb' <- mkApplicationOpenCallback (applicationOpenCallbackWrapper cb)+    connectSignalFunPtr obj "open" cb' after++-- signal Application::shutdown+type ApplicationShutdownCallback =+    IO ()++noApplicationShutdownCallback :: Maybe ApplicationShutdownCallback+noApplicationShutdownCallback = Nothing++type ApplicationShutdownCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkApplicationShutdownCallback :: ApplicationShutdownCallbackC -> IO (FunPtr ApplicationShutdownCallbackC)++applicationShutdownClosure :: ApplicationShutdownCallback -> IO Closure+applicationShutdownClosure cb = newCClosure =<< mkApplicationShutdownCallback wrapped+    where wrapped = applicationShutdownCallbackWrapper cb++applicationShutdownCallbackWrapper ::+    ApplicationShutdownCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+applicationShutdownCallbackWrapper _cb _ _ = do+    _cb ++onApplicationShutdown :: (GObject a, MonadIO m) => a -> ApplicationShutdownCallback -> m SignalHandlerId+onApplicationShutdown obj cb = liftIO $ connectApplicationShutdown obj cb SignalConnectBefore+afterApplicationShutdown :: (GObject a, MonadIO m) => a -> ApplicationShutdownCallback -> m SignalHandlerId+afterApplicationShutdown obj cb = connectApplicationShutdown obj cb SignalConnectAfter++connectApplicationShutdown :: (GObject a, MonadIO m) =>+                              a -> ApplicationShutdownCallback -> SignalConnectMode -> m SignalHandlerId+connectApplicationShutdown obj cb after = liftIO $ do+    cb' <- mkApplicationShutdownCallback (applicationShutdownCallbackWrapper cb)+    connectSignalFunPtr obj "shutdown" cb' after++-- signal Application::startup+type ApplicationStartupCallback =+    IO ()++noApplicationStartupCallback :: Maybe ApplicationStartupCallback+noApplicationStartupCallback = Nothing++type ApplicationStartupCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkApplicationStartupCallback :: ApplicationStartupCallbackC -> IO (FunPtr ApplicationStartupCallbackC)++applicationStartupClosure :: ApplicationStartupCallback -> IO Closure+applicationStartupClosure cb = newCClosure =<< mkApplicationStartupCallback wrapped+    where wrapped = applicationStartupCallbackWrapper cb++applicationStartupCallbackWrapper ::+    ApplicationStartupCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+applicationStartupCallbackWrapper _cb _ _ = do+    _cb ++onApplicationStartup :: (GObject a, MonadIO m) => a -> ApplicationStartupCallback -> m SignalHandlerId+onApplicationStartup obj cb = liftIO $ connectApplicationStartup obj cb SignalConnectBefore+afterApplicationStartup :: (GObject a, MonadIO m) => a -> ApplicationStartupCallback -> m SignalHandlerId+afterApplicationStartup obj cb = connectApplicationStartup obj cb SignalConnectAfter++connectApplicationStartup :: (GObject a, MonadIO m) =>+                             a -> ApplicationStartupCallback -> SignalConnectMode -> m SignalHandlerId+connectApplicationStartup obj cb after = liftIO $ do+    cb' <- mkApplicationStartupCallback (applicationStartupCallbackWrapper cb)+    connectSignalFunPtr obj "startup" cb' after++-- VVV Prop "action-group"+   -- Type: TInterface "Gio" "ActionGroup"+   -- Flags: [PropertyWritable]++setApplicationActionGroup :: (MonadIO m, ApplicationK o, ActionGroupK a) => o -> a -> m ()+setApplicationActionGroup obj val = liftIO $ setObjectPropertyObject obj "action-group" val++constructApplicationActionGroup :: (ActionGroupK a) => a -> IO ([Char], GValue)+constructApplicationActionGroup val = constructObjectPropertyObject "action-group" val++data ApplicationActionGroupPropertyInfo+instance AttrInfo ApplicationActionGroupPropertyInfo where+    type AttrAllowedOps ApplicationActionGroupPropertyInfo = '[ 'AttrSet, 'AttrConstruct]+    type AttrSetTypeConstraint ApplicationActionGroupPropertyInfo = ActionGroupK+    type AttrBaseTypeConstraint ApplicationActionGroupPropertyInfo = ApplicationK+    type AttrGetType ApplicationActionGroupPropertyInfo = ()+    type AttrLabel ApplicationActionGroupPropertyInfo = "Application::action-group"+    attrGet _ = undefined+    attrSet _ = setApplicationActionGroup+    attrConstruct _ = constructApplicationActionGroup++-- VVV Prop "application-id"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getApplicationApplicationId :: (MonadIO m, ApplicationK o) => o -> m T.Text+getApplicationApplicationId obj = liftIO $ getObjectPropertyString obj "application-id"++setApplicationApplicationId :: (MonadIO m, ApplicationK o) => o -> T.Text -> m ()+setApplicationApplicationId obj val = liftIO $ setObjectPropertyString obj "application-id" val++constructApplicationApplicationId :: T.Text -> IO ([Char], GValue)+constructApplicationApplicationId val = constructObjectPropertyString "application-id" val++data ApplicationApplicationIdPropertyInfo+instance AttrInfo ApplicationApplicationIdPropertyInfo where+    type AttrAllowedOps ApplicationApplicationIdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ApplicationApplicationIdPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ApplicationApplicationIdPropertyInfo = ApplicationK+    type AttrGetType ApplicationApplicationIdPropertyInfo = T.Text+    type AttrLabel ApplicationApplicationIdPropertyInfo = "Application::application-id"+    attrGet _ = getApplicationApplicationId+    attrSet _ = setApplicationApplicationId+    attrConstruct _ = constructApplicationApplicationId++-- VVV Prop "flags"+   -- Type: TInterface "Gio" "ApplicationFlags"+   -- Flags: [PropertyReadable,PropertyWritable]++getApplicationFlags :: (MonadIO m, ApplicationK o) => o -> m [ApplicationFlags]+getApplicationFlags obj = liftIO $ getObjectPropertyFlags obj "flags"++setApplicationFlags :: (MonadIO m, ApplicationK o) => o -> [ApplicationFlags] -> m ()+setApplicationFlags obj val = liftIO $ setObjectPropertyFlags obj "flags" val++constructApplicationFlags :: [ApplicationFlags] -> IO ([Char], GValue)+constructApplicationFlags val = constructObjectPropertyFlags "flags" val++data ApplicationFlagsPropertyInfo+instance AttrInfo ApplicationFlagsPropertyInfo where+    type AttrAllowedOps ApplicationFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ApplicationFlagsPropertyInfo = (~) [ApplicationFlags]+    type AttrBaseTypeConstraint ApplicationFlagsPropertyInfo = ApplicationK+    type AttrGetType ApplicationFlagsPropertyInfo = [ApplicationFlags]+    type AttrLabel ApplicationFlagsPropertyInfo = "Application::flags"+    attrGet _ = getApplicationFlags+    attrSet _ = setApplicationFlags+    attrConstruct _ = constructApplicationFlags++-- VVV Prop "inactivity-timeout"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getApplicationInactivityTimeout :: (MonadIO m, ApplicationK o) => o -> m Word32+getApplicationInactivityTimeout obj = liftIO $ getObjectPropertyCUInt obj "inactivity-timeout"++setApplicationInactivityTimeout :: (MonadIO m, ApplicationK o) => o -> Word32 -> m ()+setApplicationInactivityTimeout obj val = liftIO $ setObjectPropertyCUInt obj "inactivity-timeout" val++constructApplicationInactivityTimeout :: Word32 -> IO ([Char], GValue)+constructApplicationInactivityTimeout val = constructObjectPropertyCUInt "inactivity-timeout" val++data ApplicationInactivityTimeoutPropertyInfo+instance AttrInfo ApplicationInactivityTimeoutPropertyInfo where+    type AttrAllowedOps ApplicationInactivityTimeoutPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ApplicationInactivityTimeoutPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint ApplicationInactivityTimeoutPropertyInfo = ApplicationK+    type AttrGetType ApplicationInactivityTimeoutPropertyInfo = Word32+    type AttrLabel ApplicationInactivityTimeoutPropertyInfo = "Application::inactivity-timeout"+    attrGet _ = getApplicationInactivityTimeout+    attrSet _ = setApplicationInactivityTimeout+    attrConstruct _ = constructApplicationInactivityTimeout++-- VVV Prop "is-busy"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getApplicationIsBusy :: (MonadIO m, ApplicationK o) => o -> m Bool+getApplicationIsBusy obj = liftIO $ getObjectPropertyBool obj "is-busy"++data ApplicationIsBusyPropertyInfo+instance AttrInfo ApplicationIsBusyPropertyInfo where+    type AttrAllowedOps ApplicationIsBusyPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint ApplicationIsBusyPropertyInfo = (~) ()+    type AttrBaseTypeConstraint ApplicationIsBusyPropertyInfo = ApplicationK+    type AttrGetType ApplicationIsBusyPropertyInfo = Bool+    type AttrLabel ApplicationIsBusyPropertyInfo = "Application::is-busy"+    attrGet _ = getApplicationIsBusy+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "is-registered"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getApplicationIsRegistered :: (MonadIO m, ApplicationK o) => o -> m Bool+getApplicationIsRegistered obj = liftIO $ getObjectPropertyBool obj "is-registered"++data ApplicationIsRegisteredPropertyInfo+instance AttrInfo ApplicationIsRegisteredPropertyInfo where+    type AttrAllowedOps ApplicationIsRegisteredPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint ApplicationIsRegisteredPropertyInfo = (~) ()+    type AttrBaseTypeConstraint ApplicationIsRegisteredPropertyInfo = ApplicationK+    type AttrGetType ApplicationIsRegisteredPropertyInfo = Bool+    type AttrLabel ApplicationIsRegisteredPropertyInfo = "Application::is-registered"+    attrGet _ = getApplicationIsRegistered+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "is-remote"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getApplicationIsRemote :: (MonadIO m, ApplicationK o) => o -> m Bool+getApplicationIsRemote obj = liftIO $ getObjectPropertyBool obj "is-remote"++data ApplicationIsRemotePropertyInfo+instance AttrInfo ApplicationIsRemotePropertyInfo where+    type AttrAllowedOps ApplicationIsRemotePropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint ApplicationIsRemotePropertyInfo = (~) ()+    type AttrBaseTypeConstraint ApplicationIsRemotePropertyInfo = ApplicationK+    type AttrGetType ApplicationIsRemotePropertyInfo = Bool+    type AttrLabel ApplicationIsRemotePropertyInfo = "Application::is-remote"+    attrGet _ = getApplicationIsRemote+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "resource-base-path"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getApplicationResourceBasePath :: (MonadIO m, ApplicationK o) => o -> m T.Text+getApplicationResourceBasePath obj = liftIO $ getObjectPropertyString obj "resource-base-path"++setApplicationResourceBasePath :: (MonadIO m, ApplicationK o) => o -> T.Text -> m ()+setApplicationResourceBasePath obj val = liftIO $ setObjectPropertyString obj "resource-base-path" val++constructApplicationResourceBasePath :: T.Text -> IO ([Char], GValue)+constructApplicationResourceBasePath val = constructObjectPropertyString "resource-base-path" val++data ApplicationResourceBasePathPropertyInfo+instance AttrInfo ApplicationResourceBasePathPropertyInfo where+    type AttrAllowedOps ApplicationResourceBasePathPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ApplicationResourceBasePathPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ApplicationResourceBasePathPropertyInfo = ApplicationK+    type AttrGetType ApplicationResourceBasePathPropertyInfo = T.Text+    type AttrLabel ApplicationResourceBasePathPropertyInfo = "Application::resource-base-path"+    attrGet _ = getApplicationResourceBasePath+    attrSet _ = setApplicationResourceBasePath+    attrConstruct _ = constructApplicationResourceBasePath++type instance AttributeList Application = ApplicationAttributeList+type ApplicationAttributeList = ('[ '("action-group", ApplicationActionGroupPropertyInfo), '("application-id", ApplicationApplicationIdPropertyInfo), '("flags", ApplicationFlagsPropertyInfo), '("inactivity-timeout", ApplicationInactivityTimeoutPropertyInfo), '("is-busy", ApplicationIsBusyPropertyInfo), '("is-registered", ApplicationIsRegisteredPropertyInfo), '("is-remote", ApplicationIsRemotePropertyInfo), '("resource-base-path", ApplicationResourceBasePathPropertyInfo)] :: [(Symbol, *)])++data ApplicationActivateSignalInfo+instance SignalInfo ApplicationActivateSignalInfo where+    type HaskellCallbackType ApplicationActivateSignalInfo = ApplicationActivateCallback+    connectSignal _ = connectApplicationActivate++data ApplicationCommandLineSignalInfo+instance SignalInfo ApplicationCommandLineSignalInfo where+    type HaskellCallbackType ApplicationCommandLineSignalInfo = ApplicationCommandLineCallback+    connectSignal _ = connectApplicationCommandLine++data ApplicationHandleLocalOptionsSignalInfo+instance SignalInfo ApplicationHandleLocalOptionsSignalInfo where+    type HaskellCallbackType ApplicationHandleLocalOptionsSignalInfo = ApplicationHandleLocalOptionsCallback+    connectSignal _ = connectApplicationHandleLocalOptions++data ApplicationOpenSignalInfo+instance SignalInfo ApplicationOpenSignalInfo where+    type HaskellCallbackType ApplicationOpenSignalInfo = ApplicationOpenCallback+    connectSignal _ = connectApplicationOpen++data ApplicationShutdownSignalInfo+instance SignalInfo ApplicationShutdownSignalInfo where+    type HaskellCallbackType ApplicationShutdownSignalInfo = ApplicationShutdownCallback+    connectSignal _ = connectApplicationShutdown++data ApplicationStartupSignalInfo+instance SignalInfo ApplicationStartupSignalInfo where+    type HaskellCallbackType ApplicationStartupSignalInfo = ApplicationStartupCallback+    connectSignal _ = connectApplicationStartup++type instance SignalList Application = ApplicationSignalList+type ApplicationSignalList = ('[ '("action-added", ActionGroupActionAddedSignalInfo), '("action-enabled-changed", ActionGroupActionEnabledChangedSignalInfo), '("action-removed", ActionGroupActionRemovedSignalInfo), '("action-state-changed", ActionGroupActionStateChangedSignalInfo), '("activate", ApplicationActivateSignalInfo), '("command-line", ApplicationCommandLineSignalInfo), '("handle-local-options", ApplicationHandleLocalOptionsSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("open", ApplicationOpenSignalInfo), '("shutdown", ApplicationShutdownSignalInfo), '("startup", ApplicationStartupSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Application::new+-- method type : Constructor+-- Args : [Arg {argName = "application_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "ApplicationFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "application_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "ApplicationFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Application"+-- throws : False+-- Skip return : False++foreign import ccall "g_application_new" g_application_new :: +    CString ->                              -- application_id : TBasicType TUTF8+    CUInt ->                                -- flags : TInterface "Gio" "ApplicationFlags"+    IO (Ptr Application)+++applicationNew ::+    (MonadIO m) =>+    Maybe (T.Text) ->                       -- application_id+    [ApplicationFlags] ->                   -- flags+    m Application+applicationNew application_id flags = liftIO $ do+    maybeApplication_id <- case application_id of+        Nothing -> return nullPtr+        Just jApplication_id -> do+            jApplication_id' <- textToCString jApplication_id+            return jApplication_id'+    let flags' = gflagsToWord flags+    result <- g_application_new maybeApplication_id flags'+    checkUnexpectedReturnNULL "g_application_new" result+    result' <- (wrapObject Application) result+    freeMem maybeApplication_id+    return result'++-- method Application::activate+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_application_activate" g_application_activate :: +    Ptr Application ->                      -- _obj : TInterface "Gio" "Application"+    IO ()+++applicationActivate ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    m ()+applicationActivate _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_application_activate _obj'+    touchManagedPtr _obj+    return ()++-- method Application::add_main_option+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "long_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "short_name", argType = TBasicType TInt8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "GLib" "OptionFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "arg", argType = TInterface "GLib" "OptionArg", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "description", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "arg_description", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "long_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "short_name", argType = TBasicType TInt8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "GLib" "OptionFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "arg", argType = TInterface "GLib" "OptionArg", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "description", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "arg_description", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_application_add_main_option" g_application_add_main_option :: +    Ptr Application ->                      -- _obj : TInterface "Gio" "Application"+    CString ->                              -- long_name : TBasicType TUTF8+    Int8 ->                                 -- short_name : TBasicType TInt8+    CUInt ->                                -- flags : TInterface "GLib" "OptionFlags"+    CUInt ->                                -- arg : TInterface "GLib" "OptionArg"+    CString ->                              -- description : TBasicType TUTF8+    CString ->                              -- arg_description : TBasicType TUTF8+    IO ()+++applicationAddMainOption ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- long_name+    Int8 ->                                 -- short_name+    [GLib.OptionFlags] ->                   -- flags+    GLib.OptionArg ->                       -- arg+    T.Text ->                               -- description+    Maybe (T.Text) ->                       -- arg_description+    m ()+applicationAddMainOption _obj long_name short_name flags arg description arg_description = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    long_name' <- textToCString long_name+    let flags' = gflagsToWord flags+    let arg' = (fromIntegral . fromEnum) arg+    description' <- textToCString description+    maybeArg_description <- case arg_description of+        Nothing -> return nullPtr+        Just jArg_description -> do+            jArg_description' <- textToCString jArg_description+            return jArg_description'+    g_application_add_main_option _obj' long_name' short_name flags' arg' description' maybeArg_description+    touchManagedPtr _obj+    freeMem long_name'+    freeMem description'+    freeMem maybeArg_description+    return ()++-- method Application::add_main_option_entries+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "entries", argType = TCArray True (-1) (-1) (TInterface "GLib" "OptionEntry"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "entries", argType = TCArray True (-1) (-1) (TInterface "GLib" "OptionEntry"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_application_add_main_option_entries" g_application_add_main_option_entries :: +    Ptr Application ->                      -- _obj : TInterface "Gio" "Application"+    Ptr (Ptr GLib.OptionEntry) ->           -- entries : TCArray True (-1) (-1) (TInterface "GLib" "OptionEntry")+    IO ()+++applicationAddMainOptionEntries ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    [GLib.OptionEntry] ->                   -- entries+    m ()+applicationAddMainOptionEntries _obj entries = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let entries' = map unsafeManagedPtrGetPtr entries+    entries'' <- packZeroTerminatedPtrArray entries'+    g_application_add_main_option_entries _obj' entries''+    touchManagedPtr _obj+    mapM_ touchManagedPtr entries+    freeMem entries''+    return ()++-- method Application::add_option_group+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "group", argType = TInterface "GLib" "OptionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "group", argType = TInterface "GLib" "OptionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_application_add_option_group" g_application_add_option_group :: +    Ptr Application ->                      -- _obj : TInterface "Gio" "Application"+    Ptr GLib.OptionGroup ->                 -- group : TInterface "GLib" "OptionGroup"+    IO ()+++applicationAddOptionGroup ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    GLib.OptionGroup ->                     -- group+    m ()+applicationAddOptionGroup _obj group = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let group' = unsafeManagedPtrGetPtr group+    g_application_add_option_group _obj' group'+    touchManagedPtr _obj+    touchManagedPtr group+    return ()++-- method Application::bind_busy_property+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "property", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "property", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_application_bind_busy_property" g_application_bind_busy_property :: +    Ptr Application ->                      -- _obj : TInterface "Gio" "Application"+    Ptr GObject.Object ->                   -- object : TInterface "GObject" "Object"+    CString ->                              -- property : TBasicType TUTF8+    IO ()+++applicationBindBusyProperty ::+    (MonadIO m, ApplicationK a, GObject.ObjectK b) =>+    a ->                                    -- _obj+    b ->                                    -- object+    T.Text ->                               -- property+    m ()+applicationBindBusyProperty _obj object property = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let object' = unsafeManagedPtrCastPtr object+    property' <- textToCString property+    g_application_bind_busy_property _obj' object' property'+    touchManagedPtr _obj+    touchManagedPtr object+    freeMem property'+    return ()++-- method Application::get_application_id+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_application_get_application_id" g_application_get_application_id :: +    Ptr Application ->                      -- _obj : TInterface "Gio" "Application"+    IO CString+++applicationGetApplicationId ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    m T.Text+applicationGetApplicationId _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_application_get_application_id _obj'+    checkUnexpectedReturnNULL "g_application_get_application_id" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Application::get_dbus_connection+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusConnection"+-- throws : False+-- Skip return : False++foreign import ccall "g_application_get_dbus_connection" g_application_get_dbus_connection :: +    Ptr Application ->                      -- _obj : TInterface "Gio" "Application"+    IO (Ptr DBusConnection)+++applicationGetDbusConnection ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    m DBusConnection+applicationGetDbusConnection _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_application_get_dbus_connection _obj'+    checkUnexpectedReturnNULL "g_application_get_dbus_connection" result+    result' <- (newObject DBusConnection) result+    touchManagedPtr _obj+    return result'++-- method Application::get_dbus_object_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_application_get_dbus_object_path" g_application_get_dbus_object_path :: +    Ptr Application ->                      -- _obj : TInterface "Gio" "Application"+    IO CString+++applicationGetDbusObjectPath ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    m T.Text+applicationGetDbusObjectPath _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_application_get_dbus_object_path _obj'+    checkUnexpectedReturnNULL "g_application_get_dbus_object_path" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Application::get_flags+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "ApplicationFlags"+-- throws : False+-- Skip return : False++foreign import ccall "g_application_get_flags" g_application_get_flags :: +    Ptr Application ->                      -- _obj : TInterface "Gio" "Application"+    IO CUInt+++applicationGetFlags ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    m [ApplicationFlags]+applicationGetFlags _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_application_get_flags _obj'+    let result' = wordToGFlags result+    touchManagedPtr _obj+    return result'++-- method Application::get_inactivity_timeout+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_application_get_inactivity_timeout" g_application_get_inactivity_timeout :: +    Ptr Application ->                      -- _obj : TInterface "Gio" "Application"+    IO Word32+++applicationGetInactivityTimeout ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    m Word32+applicationGetInactivityTimeout _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_application_get_inactivity_timeout _obj'+    touchManagedPtr _obj+    return result++-- method Application::get_is_busy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_application_get_is_busy" g_application_get_is_busy :: +    Ptr Application ->                      -- _obj : TInterface "Gio" "Application"+    IO CInt+++applicationGetIsBusy ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    m Bool+applicationGetIsBusy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_application_get_is_busy _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Application::get_is_registered+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_application_get_is_registered" g_application_get_is_registered :: +    Ptr Application ->                      -- _obj : TInterface "Gio" "Application"+    IO CInt+++applicationGetIsRegistered ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    m Bool+applicationGetIsRegistered _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_application_get_is_registered _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Application::get_is_remote+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_application_get_is_remote" g_application_get_is_remote :: +    Ptr Application ->                      -- _obj : TInterface "Gio" "Application"+    IO CInt+++applicationGetIsRemote ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    m Bool+applicationGetIsRemote _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_application_get_is_remote _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Application::get_resource_base_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_application_get_resource_base_path" g_application_get_resource_base_path :: +    Ptr Application ->                      -- _obj : TInterface "Gio" "Application"+    IO CString+++applicationGetResourceBasePath ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    m T.Text+applicationGetResourceBasePath _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_application_get_resource_base_path _obj'+    checkUnexpectedReturnNULL "g_application_get_resource_base_path" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Application::hold+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_application_hold" g_application_hold :: +    Ptr Application ->                      -- _obj : TInterface "Gio" "Application"+    IO ()+++applicationHold ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    m ()+applicationHold _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_application_hold _obj'+    touchManagedPtr _obj+    return ()++-- method Application::mark_busy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_application_mark_busy" g_application_mark_busy :: +    Ptr Application ->                      -- _obj : TInterface "Gio" "Application"+    IO ()+++applicationMarkBusy ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    m ()+applicationMarkBusy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_application_mark_busy _obj'+    touchManagedPtr _obj+    return ()++-- method Application::open+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "files", argType = TCArray False (-1) 2 (TInterface "Gio" "File"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_files", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "hint", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "n_files", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "files", argType = TCArray False (-1) 2 (TInterface "Gio" "File"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "hint", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_application_open" g_application_open :: +    Ptr Application ->                      -- _obj : TInterface "Gio" "Application"+    Ptr (Ptr File) ->                       -- files : TCArray False (-1) 2 (TInterface "Gio" "File")+    Int32 ->                                -- n_files : TBasicType TInt32+    CString ->                              -- hint : TBasicType TUTF8+    IO ()+++applicationOpen ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    [File] ->                               -- files+    T.Text ->                               -- hint+    m ()+applicationOpen _obj files hint = liftIO $ do+    let n_files = fromIntegral $ length files+    let _obj' = unsafeManagedPtrCastPtr _obj+    let files' = map unsafeManagedPtrCastPtr files+    files'' <- packPtrArray files'+    hint' <- textToCString hint+    g_application_open _obj' files'' n_files hint'+    touchManagedPtr _obj+    mapM_ touchManagedPtr files+    freeMem files''+    freeMem hint'+    return ()++-- method Application::quit+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_application_quit" g_application_quit :: +    Ptr Application ->                      -- _obj : TInterface "Gio" "Application"+    IO ()+++applicationQuit ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    m ()+applicationQuit _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_application_quit _obj'+    touchManagedPtr _obj+    return ()++-- method Application::register+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_application_register" g_application_register :: +    Ptr Application ->                      -- _obj : TInterface "Gio" "Application"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++applicationRegister ::+    (MonadIO m, ApplicationK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m ()+applicationRegister _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_application_register _obj' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method Application::release+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_application_release" g_application_release :: +    Ptr Application ->                      -- _obj : TInterface "Gio" "Application"+    IO ()+++applicationRelease ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    m ()+applicationRelease _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_application_release _obj'+    touchManagedPtr _obj+    return ()++-- method Application::run+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "argc", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "argv", argType = TCArray False (-1) 1 (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "argc", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "argv", argType = TCArray False (-1) 1 (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_application_run" g_application_run :: +    Ptr Application ->                      -- _obj : TInterface "Gio" "Application"+    Int32 ->                                -- argc : TBasicType TInt32+    Ptr CString ->                          -- argv : TCArray False (-1) 1 (TBasicType TUTF8)+    IO Int32+++applicationRun ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    Maybe ([T.Text]) ->                     -- argv+    m Int32+applicationRun _obj argv = liftIO $ do+    let argc = case argv of+            Nothing -> 0+            Just jArgv -> fromIntegral $ length jArgv+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeArgv <- case argv of+        Nothing -> return nullPtr+        Just jArgv -> do+            jArgv' <- packUTF8CArray jArgv+            return jArgv'+    result <- g_application_run _obj' argc maybeArgv+    touchManagedPtr _obj+    (mapCArrayWithLength argc) freeMem maybeArgv+    freeMem maybeArgv+    return result++-- method Application::send_notification+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "notification", argType = TInterface "Gio" "Notification", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "notification", argType = TInterface "Gio" "Notification", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_application_send_notification" g_application_send_notification :: +    Ptr Application ->                      -- _obj : TInterface "Gio" "Application"+    CString ->                              -- id : TBasicType TUTF8+    Ptr Notification ->                     -- notification : TInterface "Gio" "Notification"+    IO ()+++applicationSendNotification ::+    (MonadIO m, ApplicationK a, NotificationK b) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- id+    b ->                                    -- notification+    m ()+applicationSendNotification _obj id notification = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeId <- case id of+        Nothing -> return nullPtr+        Just jId -> do+            jId' <- textToCString jId+            return jId'+    let notification' = unsafeManagedPtrCastPtr notification+    g_application_send_notification _obj' maybeId notification'+    touchManagedPtr _obj+    touchManagedPtr notification+    freeMem maybeId+    return ()++-- method Application::set_action_group+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_group", argType = TInterface "Gio" "ActionGroup", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_group", argType = TInterface "Gio" "ActionGroup", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_application_set_action_group" g_application_set_action_group :: +    Ptr Application ->                      -- _obj : TInterface "Gio" "Application"+    Ptr ActionGroup ->                      -- action_group : TInterface "Gio" "ActionGroup"+    IO ()++{-# DEPRECATED applicationSetActionGroup ["(Since version 2.32)","Use the #GActionMap interface instead.  Never ever","mix use of this API with use of #GActionMap on the same @application","or things will go very badly wrong.  This function is known to","introduce buggy behaviour (ie: signals not emitted on changes to the","action group), so you should really use #GActionMap instead."]#-}+applicationSetActionGroup ::+    (MonadIO m, ApplicationK a, ActionGroupK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- action_group+    m ()+applicationSetActionGroup _obj action_group = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeAction_group <- case action_group of+        Nothing -> return nullPtr+        Just jAction_group -> do+            let jAction_group' = unsafeManagedPtrCastPtr jAction_group+            return jAction_group'+    g_application_set_action_group _obj' maybeAction_group+    touchManagedPtr _obj+    whenJust action_group touchManagedPtr+    return ()++-- method Application::set_application_id+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "application_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "application_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_application_set_application_id" g_application_set_application_id :: +    Ptr Application ->                      -- _obj : TInterface "Gio" "Application"+    CString ->                              -- application_id : TBasicType TUTF8+    IO ()+++applicationSetApplicationId ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- application_id+    m ()+applicationSetApplicationId _obj application_id = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeApplication_id <- case application_id of+        Nothing -> return nullPtr+        Just jApplication_id -> do+            jApplication_id' <- textToCString jApplication_id+            return jApplication_id'+    g_application_set_application_id _obj' maybeApplication_id+    touchManagedPtr _obj+    freeMem maybeApplication_id+    return ()++-- method Application::set_default+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_application_set_default" g_application_set_default :: +    Ptr Application ->                      -- _obj : TInterface "Gio" "Application"+    IO ()+++applicationSetDefault ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    m ()+applicationSetDefault _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_application_set_default _obj'+    touchManagedPtr _obj+    return ()++-- method Application::set_flags+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "ApplicationFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "ApplicationFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_application_set_flags" g_application_set_flags :: +    Ptr Application ->                      -- _obj : TInterface "Gio" "Application"+    CUInt ->                                -- flags : TInterface "Gio" "ApplicationFlags"+    IO ()+++applicationSetFlags ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    [ApplicationFlags] ->                   -- flags+    m ()+applicationSetFlags _obj flags = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    g_application_set_flags _obj' flags'+    touchManagedPtr _obj+    return ()++-- method Application::set_inactivity_timeout+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "inactivity_timeout", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "inactivity_timeout", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_application_set_inactivity_timeout" g_application_set_inactivity_timeout :: +    Ptr Application ->                      -- _obj : TInterface "Gio" "Application"+    Word32 ->                               -- inactivity_timeout : TBasicType TUInt32+    IO ()+++applicationSetInactivityTimeout ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- inactivity_timeout+    m ()+applicationSetInactivityTimeout _obj inactivity_timeout = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_application_set_inactivity_timeout _obj' inactivity_timeout+    touchManagedPtr _obj+    return ()++-- method Application::set_resource_base_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "resource_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "resource_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_application_set_resource_base_path" g_application_set_resource_base_path :: +    Ptr Application ->                      -- _obj : TInterface "Gio" "Application"+    CString ->                              -- resource_path : TBasicType TUTF8+    IO ()+++applicationSetResourceBasePath ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- resource_path+    m ()+applicationSetResourceBasePath _obj resource_path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeResource_path <- case resource_path of+        Nothing -> return nullPtr+        Just jResource_path -> do+            jResource_path' <- textToCString jResource_path+            return jResource_path'+    g_application_set_resource_base_path _obj' maybeResource_path+    touchManagedPtr _obj+    freeMem maybeResource_path+    return ()++-- method Application::unbind_busy_property+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "property", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "property", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_application_unbind_busy_property" g_application_unbind_busy_property :: +    Ptr Application ->                      -- _obj : TInterface "Gio" "Application"+    Ptr GObject.Object ->                   -- object : TInterface "GObject" "Object"+    CString ->                              -- property : TBasicType TUTF8+    IO ()+++applicationUnbindBusyProperty ::+    (MonadIO m, ApplicationK a, GObject.ObjectK b) =>+    a ->                                    -- _obj+    b ->                                    -- object+    T.Text ->                               -- property+    m ()+applicationUnbindBusyProperty _obj object property = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let object' = unsafeManagedPtrCastPtr object+    property' <- textToCString property+    g_application_unbind_busy_property _obj' object' property'+    touchManagedPtr _obj+    touchManagedPtr object+    freeMem property'+    return ()++-- method Application::unmark_busy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_application_unmark_busy" g_application_unmark_busy :: +    Ptr Application ->                      -- _obj : TInterface "Gio" "Application"+    IO ()+++applicationUnmarkBusy ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    m ()+applicationUnmarkBusy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_application_unmark_busy _obj'+    touchManagedPtr _obj+    return ()++-- method Application::withdraw_notification+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_application_withdraw_notification" g_application_withdraw_notification :: +    Ptr Application ->                      -- _obj : TInterface "Gio" "Application"+    CString ->                              -- id : TBasicType TUTF8+    IO ()+++applicationWithdrawNotification ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- id+    m ()+applicationWithdrawNotification _obj id = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    id' <- textToCString id+    g_application_withdraw_notification _obj' id'+    touchManagedPtr _obj+    freeMem id'+    return ()++-- method Application::get_default+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gio" "Application"+-- throws : False+-- Skip return : False++foreign import ccall "g_application_get_default" g_application_get_default :: +    IO (Ptr Application)+++applicationGetDefault ::+    (MonadIO m) =>+    m Application+applicationGetDefault  = liftIO $ do+    result <- g_application_get_default+    checkUnexpectedReturnNULL "g_application_get_default" result+    result' <- (newObject Application) result+    return result'++-- method Application::id_is_valid+-- method type : MemberFunction+-- Args : [Arg {argName = "application_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "application_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_application_id_is_valid" g_application_id_is_valid :: +    CString ->                              -- application_id : TBasicType TUTF8+    IO CInt+++applicationIdIsValid ::+    (MonadIO m) =>+    T.Text ->                               -- application_id+    m Bool+applicationIdIsValid application_id = liftIO $ do+    application_id' <- textToCString application_id+    result <- g_application_id_is_valid application_id'+    let result' = (/= 0) result+    freeMem application_id'+    return result'++
+ GI/Gio/Objects/Application.hs-boot view
@@ -0,0 +1,27 @@+module GI.Gio.Objects.Application where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Application = Application (ForeignPtr Application)+instance GObject Application where+class GObject o => ApplicationK o+instance (GObject o, IsDescendantOf Application o) => ApplicationK o+data ApplicationActionGroupPropertyInfo+data ApplicationApplicationIdPropertyInfo+data ApplicationFlagsPropertyInfo+data ApplicationInactivityTimeoutPropertyInfo+data ApplicationIsBusyPropertyInfo+data ApplicationIsRegisteredPropertyInfo+data ApplicationIsRemotePropertyInfo+data ApplicationResourceBasePathPropertyInfo+data ApplicationActivateSignalInfo+data ApplicationCommandLineSignalInfo+data ApplicationHandleLocalOptionsSignalInfo+data ApplicationOpenSignalInfo+data ApplicationShutdownSignalInfo+data ApplicationStartupSignalInfo
+ GI/Gio/Objects/ApplicationCommandLine.hs view
@@ -0,0 +1,498 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.ApplicationCommandLine+    ( ++-- * Exported types+    ApplicationCommandLine(..)              ,+    ApplicationCommandLineK                 ,+    toApplicationCommandLine                ,+    noApplicationCommandLine                ,+++ -- * Methods+-- ** applicationCommandLineCreateFileForArg+    applicationCommandLineCreateFileForArg  ,+++-- ** applicationCommandLineGetArguments+    applicationCommandLineGetArguments      ,+++-- ** applicationCommandLineGetCwd+    applicationCommandLineGetCwd            ,+++-- ** applicationCommandLineGetEnviron+    applicationCommandLineGetEnviron        ,+++-- ** applicationCommandLineGetExitStatus+    applicationCommandLineGetExitStatus     ,+++-- ** applicationCommandLineGetIsRemote+    applicationCommandLineGetIsRemote       ,+++-- ** applicationCommandLineGetOptionsDict+    applicationCommandLineGetOptionsDict    ,+++-- ** applicationCommandLineGetPlatformData+    applicationCommandLineGetPlatformData   ,+++-- ** applicationCommandLineGetStdin+    applicationCommandLineGetStdin          ,+++-- ** applicationCommandLineGetenv+    applicationCommandLineGetenv            ,+++-- ** applicationCommandLineSetExitStatus+    applicationCommandLineSetExitStatus     ,+++++ -- * Properties+-- ** Arguments+    ApplicationCommandLineArgumentsPropertyInfo,+    constructApplicationCommandLineArguments,+++-- ** IsRemote+    ApplicationCommandLineIsRemotePropertyInfo,+    getApplicationCommandLineIsRemote       ,+++-- ** Options+    ApplicationCommandLineOptionsPropertyInfo,+    constructApplicationCommandLineOptions  ,+++-- ** PlatformData+    ApplicationCommandLinePlatformDataPropertyInfo,+    constructApplicationCommandLinePlatformData,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype ApplicationCommandLine = ApplicationCommandLine (ForeignPtr ApplicationCommandLine)+foreign import ccall "g_application_command_line_get_type"+    c_g_application_command_line_get_type :: IO GType++type instance ParentTypes ApplicationCommandLine = ApplicationCommandLineParentTypes+type ApplicationCommandLineParentTypes = '[GObject.Object]++instance GObject ApplicationCommandLine where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_application_command_line_get_type+    ++class GObject o => ApplicationCommandLineK o+instance (GObject o, IsDescendantOf ApplicationCommandLine o) => ApplicationCommandLineK o++toApplicationCommandLine :: ApplicationCommandLineK o => o -> IO ApplicationCommandLine+toApplicationCommandLine = unsafeCastTo ApplicationCommandLine++noApplicationCommandLine :: Maybe ApplicationCommandLine+noApplicationCommandLine = Nothing++-- VVV Prop "arguments"+   -- Type: TVariant+   -- Flags: [PropertyWritable,PropertyConstructOnly]++constructApplicationCommandLineArguments :: GVariant -> IO ([Char], GValue)+constructApplicationCommandLineArguments val = constructObjectPropertyVariant "arguments" val++data ApplicationCommandLineArgumentsPropertyInfo+instance AttrInfo ApplicationCommandLineArgumentsPropertyInfo where+    type AttrAllowedOps ApplicationCommandLineArgumentsPropertyInfo = '[ 'AttrConstruct]+    type AttrSetTypeConstraint ApplicationCommandLineArgumentsPropertyInfo = (~) GVariant+    type AttrBaseTypeConstraint ApplicationCommandLineArgumentsPropertyInfo = ApplicationCommandLineK+    type AttrGetType ApplicationCommandLineArgumentsPropertyInfo = ()+    type AttrLabel ApplicationCommandLineArgumentsPropertyInfo = "ApplicationCommandLine::arguments"+    attrGet _ = undefined+    attrSet _ = undefined+    attrConstruct _ = constructApplicationCommandLineArguments++-- VVV Prop "is-remote"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getApplicationCommandLineIsRemote :: (MonadIO m, ApplicationCommandLineK o) => o -> m Bool+getApplicationCommandLineIsRemote obj = liftIO $ getObjectPropertyBool obj "is-remote"++data ApplicationCommandLineIsRemotePropertyInfo+instance AttrInfo ApplicationCommandLineIsRemotePropertyInfo where+    type AttrAllowedOps ApplicationCommandLineIsRemotePropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint ApplicationCommandLineIsRemotePropertyInfo = (~) ()+    type AttrBaseTypeConstraint ApplicationCommandLineIsRemotePropertyInfo = ApplicationCommandLineK+    type AttrGetType ApplicationCommandLineIsRemotePropertyInfo = Bool+    type AttrLabel ApplicationCommandLineIsRemotePropertyInfo = "ApplicationCommandLine::is-remote"+    attrGet _ = getApplicationCommandLineIsRemote+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "options"+   -- Type: TVariant+   -- Flags: [PropertyWritable,PropertyConstructOnly]++constructApplicationCommandLineOptions :: GVariant -> IO ([Char], GValue)+constructApplicationCommandLineOptions val = constructObjectPropertyVariant "options" val++data ApplicationCommandLineOptionsPropertyInfo+instance AttrInfo ApplicationCommandLineOptionsPropertyInfo where+    type AttrAllowedOps ApplicationCommandLineOptionsPropertyInfo = '[ 'AttrConstruct]+    type AttrSetTypeConstraint ApplicationCommandLineOptionsPropertyInfo = (~) GVariant+    type AttrBaseTypeConstraint ApplicationCommandLineOptionsPropertyInfo = ApplicationCommandLineK+    type AttrGetType ApplicationCommandLineOptionsPropertyInfo = ()+    type AttrLabel ApplicationCommandLineOptionsPropertyInfo = "ApplicationCommandLine::options"+    attrGet _ = undefined+    attrSet _ = undefined+    attrConstruct _ = constructApplicationCommandLineOptions++-- VVV Prop "platform-data"+   -- Type: TVariant+   -- Flags: [PropertyWritable,PropertyConstructOnly]++constructApplicationCommandLinePlatformData :: GVariant -> IO ([Char], GValue)+constructApplicationCommandLinePlatformData val = constructObjectPropertyVariant "platform-data" val++data ApplicationCommandLinePlatformDataPropertyInfo+instance AttrInfo ApplicationCommandLinePlatformDataPropertyInfo where+    type AttrAllowedOps ApplicationCommandLinePlatformDataPropertyInfo = '[ 'AttrConstruct]+    type AttrSetTypeConstraint ApplicationCommandLinePlatformDataPropertyInfo = (~) GVariant+    type AttrBaseTypeConstraint ApplicationCommandLinePlatformDataPropertyInfo = ApplicationCommandLineK+    type AttrGetType ApplicationCommandLinePlatformDataPropertyInfo = ()+    type AttrLabel ApplicationCommandLinePlatformDataPropertyInfo = "ApplicationCommandLine::platform-data"+    attrGet _ = undefined+    attrSet _ = undefined+    attrConstruct _ = constructApplicationCommandLinePlatformData++type instance AttributeList ApplicationCommandLine = ApplicationCommandLineAttributeList+type ApplicationCommandLineAttributeList = ('[ '("arguments", ApplicationCommandLineArgumentsPropertyInfo), '("is-remote", ApplicationCommandLineIsRemotePropertyInfo), '("options", ApplicationCommandLineOptionsPropertyInfo), '("platform-data", ApplicationCommandLinePlatformDataPropertyInfo)] :: [(Symbol, *)])++type instance SignalList ApplicationCommandLine = ApplicationCommandLineSignalList+type ApplicationCommandLineSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method ApplicationCommandLine::create_file_for_arg+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ApplicationCommandLine", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "arg", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ApplicationCommandLine", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "arg", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "File"+-- throws : False+-- Skip return : False++foreign import ccall "g_application_command_line_create_file_for_arg" g_application_command_line_create_file_for_arg :: +    Ptr ApplicationCommandLine ->           -- _obj : TInterface "Gio" "ApplicationCommandLine"+    CString ->                              -- arg : TBasicType TUTF8+    IO (Ptr File)+++applicationCommandLineCreateFileForArg ::+    (MonadIO m, ApplicationCommandLineK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- arg+    m File+applicationCommandLineCreateFileForArg _obj arg = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    arg' <- textToCString arg+    result <- g_application_command_line_create_file_for_arg _obj' arg'+    checkUnexpectedReturnNULL "g_application_command_line_create_file_for_arg" result+    result' <- (wrapObject File) result+    touchManagedPtr _obj+    freeMem arg'+    return result'++-- method ApplicationCommandLine::get_arguments+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ApplicationCommandLine", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "argc", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : [Arg {argName = "argc", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ApplicationCommandLine", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray False (-1) 1 (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_application_command_line_get_arguments" g_application_command_line_get_arguments :: +    Ptr ApplicationCommandLine ->           -- _obj : TInterface "Gio" "ApplicationCommandLine"+    Ptr Int32 ->                            -- argc : TBasicType TInt32+    IO (Ptr CString)+++applicationCommandLineGetArguments ::+    (MonadIO m, ApplicationCommandLineK a) =>+    a ->                                    -- _obj+    m [T.Text]+applicationCommandLineGetArguments _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    argc <- allocMem :: IO (Ptr Int32)+    result <- g_application_command_line_get_arguments _obj' argc+    argc' <- peek argc+    checkUnexpectedReturnNULL "g_application_command_line_get_arguments" result+    result' <- (unpackUTF8CArrayWithLength argc') result+    (mapCArrayWithLength argc') freeMem result+    freeMem result+    touchManagedPtr _obj+    freeMem argc+    return result'++-- method ApplicationCommandLine::get_cwd+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ApplicationCommandLine", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ApplicationCommandLine", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_application_command_line_get_cwd" g_application_command_line_get_cwd :: +    Ptr ApplicationCommandLine ->           -- _obj : TInterface "Gio" "ApplicationCommandLine"+    IO CString+++applicationCommandLineGetCwd ::+    (MonadIO m, ApplicationCommandLineK a) =>+    a ->                                    -- _obj+    m T.Text+applicationCommandLineGetCwd _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_application_command_line_get_cwd _obj'+    checkUnexpectedReturnNULL "g_application_command_line_get_cwd" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method ApplicationCommandLine::get_environ+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ApplicationCommandLine", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ApplicationCommandLine", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_application_command_line_get_environ" g_application_command_line_get_environ :: +    Ptr ApplicationCommandLine ->           -- _obj : TInterface "Gio" "ApplicationCommandLine"+    IO (Ptr CString)+++applicationCommandLineGetEnviron ::+    (MonadIO m, ApplicationCommandLineK a) =>+    a ->                                    -- _obj+    m [T.Text]+applicationCommandLineGetEnviron _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_application_command_line_get_environ _obj'+    checkUnexpectedReturnNULL "g_application_command_line_get_environ" result+    result' <- unpackZeroTerminatedUTF8CArray result+    touchManagedPtr _obj+    return result'++-- method ApplicationCommandLine::get_exit_status+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ApplicationCommandLine", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ApplicationCommandLine", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_application_command_line_get_exit_status" g_application_command_line_get_exit_status :: +    Ptr ApplicationCommandLine ->           -- _obj : TInterface "Gio" "ApplicationCommandLine"+    IO Int32+++applicationCommandLineGetExitStatus ::+    (MonadIO m, ApplicationCommandLineK a) =>+    a ->                                    -- _obj+    m Int32+applicationCommandLineGetExitStatus _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_application_command_line_get_exit_status _obj'+    touchManagedPtr _obj+    return result++-- method ApplicationCommandLine::get_is_remote+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ApplicationCommandLine", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ApplicationCommandLine", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_application_command_line_get_is_remote" g_application_command_line_get_is_remote :: +    Ptr ApplicationCommandLine ->           -- _obj : TInterface "Gio" "ApplicationCommandLine"+    IO CInt+++applicationCommandLineGetIsRemote ::+    (MonadIO m, ApplicationCommandLineK a) =>+    a ->                                    -- _obj+    m Bool+applicationCommandLineGetIsRemote _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_application_command_line_get_is_remote _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method ApplicationCommandLine::get_options_dict+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ApplicationCommandLine", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ApplicationCommandLine", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GLib" "VariantDict"+-- throws : False+-- Skip return : False++foreign import ccall "g_application_command_line_get_options_dict" g_application_command_line_get_options_dict :: +    Ptr ApplicationCommandLine ->           -- _obj : TInterface "Gio" "ApplicationCommandLine"+    IO (Ptr GLib.VariantDict)+++applicationCommandLineGetOptionsDict ::+    (MonadIO m, ApplicationCommandLineK a) =>+    a ->                                    -- _obj+    m GLib.VariantDict+applicationCommandLineGetOptionsDict _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_application_command_line_get_options_dict _obj'+    checkUnexpectedReturnNULL "g_application_command_line_get_options_dict" result+    result' <- (newBoxed GLib.VariantDict) result+    touchManagedPtr _obj+    return result'++-- method ApplicationCommandLine::get_platform_data+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ApplicationCommandLine", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ApplicationCommandLine", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TVariant+-- throws : False+-- Skip return : False++foreign import ccall "g_application_command_line_get_platform_data" g_application_command_line_get_platform_data :: +    Ptr ApplicationCommandLine ->           -- _obj : TInterface "Gio" "ApplicationCommandLine"+    IO (Ptr GVariant)+++applicationCommandLineGetPlatformData ::+    (MonadIO m, ApplicationCommandLineK a) =>+    a ->                                    -- _obj+    m GVariant+applicationCommandLineGetPlatformData _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_application_command_line_get_platform_data _obj'+    checkUnexpectedReturnNULL "g_application_command_line_get_platform_data" result+    result' <- wrapGVariantPtr result+    touchManagedPtr _obj+    return result'++-- method ApplicationCommandLine::get_stdin+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ApplicationCommandLine", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ApplicationCommandLine", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "InputStream"+-- throws : False+-- Skip return : False++foreign import ccall "g_application_command_line_get_stdin" g_application_command_line_get_stdin :: +    Ptr ApplicationCommandLine ->           -- _obj : TInterface "Gio" "ApplicationCommandLine"+    IO (Ptr InputStream)+++applicationCommandLineGetStdin ::+    (MonadIO m, ApplicationCommandLineK a) =>+    a ->                                    -- _obj+    m InputStream+applicationCommandLineGetStdin _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_application_command_line_get_stdin _obj'+    checkUnexpectedReturnNULL "g_application_command_line_get_stdin" result+    result' <- (wrapObject InputStream) result+    touchManagedPtr _obj+    return result'++-- method ApplicationCommandLine::getenv+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ApplicationCommandLine", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ApplicationCommandLine", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_application_command_line_getenv" g_application_command_line_getenv :: +    Ptr ApplicationCommandLine ->           -- _obj : TInterface "Gio" "ApplicationCommandLine"+    CString ->                              -- name : TBasicType TUTF8+    IO CString+++applicationCommandLineGetenv ::+    (MonadIO m, ApplicationCommandLineK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- name+    m T.Text+applicationCommandLineGetenv _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name' <- textToCString name+    result <- g_application_command_line_getenv _obj' name'+    checkUnexpectedReturnNULL "g_application_command_line_getenv" result+    result' <- cstringToText result+    touchManagedPtr _obj+    freeMem name'+    return result'++-- method ApplicationCommandLine::set_exit_status+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ApplicationCommandLine", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "exit_status", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ApplicationCommandLine", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "exit_status", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_application_command_line_set_exit_status" g_application_command_line_set_exit_status :: +    Ptr ApplicationCommandLine ->           -- _obj : TInterface "Gio" "ApplicationCommandLine"+    Int32 ->                                -- exit_status : TBasicType TInt32+    IO ()+++applicationCommandLineSetExitStatus ::+    (MonadIO m, ApplicationCommandLineK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- exit_status+    m ()+applicationCommandLineSetExitStatus _obj exit_status = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_application_command_line_set_exit_status _obj' exit_status+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Objects/ApplicationCommandLine.hs-boot view
@@ -0,0 +1,17 @@+module GI.Gio.Objects.ApplicationCommandLine where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype ApplicationCommandLine = ApplicationCommandLine (ForeignPtr ApplicationCommandLine)+instance GObject ApplicationCommandLine where+class GObject o => ApplicationCommandLineK o+instance (GObject o, IsDescendantOf ApplicationCommandLine o) => ApplicationCommandLineK o+data ApplicationCommandLineArgumentsPropertyInfo+data ApplicationCommandLineIsRemotePropertyInfo+data ApplicationCommandLineOptionsPropertyInfo+data ApplicationCommandLinePlatformDataPropertyInfo
+ GI/Gio/Objects/BufferedInputStream.hs view
@@ -0,0 +1,485 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.BufferedInputStream+    ( ++-- * Exported types+    BufferedInputStream(..)                 ,+    BufferedInputStreamK                    ,+    toBufferedInputStream                   ,+    noBufferedInputStream                   ,+++ -- * Methods+-- ** bufferedInputStreamFill+    bufferedInputStreamFill                 ,+++-- ** bufferedInputStreamFillAsync+    bufferedInputStreamFillAsync            ,+++-- ** bufferedInputStreamFillFinish+    bufferedInputStreamFillFinish           ,+++-- ** bufferedInputStreamGetAvailable+    bufferedInputStreamGetAvailable         ,+++-- ** bufferedInputStreamGetBufferSize+    bufferedInputStreamGetBufferSize        ,+++-- ** bufferedInputStreamNew+    bufferedInputStreamNew                  ,+++-- ** bufferedInputStreamNewSized+    bufferedInputStreamNewSized             ,+++-- ** bufferedInputStreamPeek+    bufferedInputStreamPeek                 ,+++-- ** bufferedInputStreamPeekBuffer+    bufferedInputStreamPeekBuffer           ,+++-- ** bufferedInputStreamReadByte+    bufferedInputStreamReadByte             ,+++-- ** bufferedInputStreamSetBufferSize+    bufferedInputStreamSetBufferSize        ,+++++ -- * Properties+-- ** BufferSize+    BufferedInputStreamBufferSizePropertyInfo,+    constructBufferedInputStreamBufferSize  ,+    getBufferedInputStreamBufferSize        ,+    setBufferedInputStreamBufferSize        ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype BufferedInputStream = BufferedInputStream (ForeignPtr BufferedInputStream)+foreign import ccall "g_buffered_input_stream_get_type"+    c_g_buffered_input_stream_get_type :: IO GType++type instance ParentTypes BufferedInputStream = BufferedInputStreamParentTypes+type BufferedInputStreamParentTypes = '[FilterInputStream, InputStream, GObject.Object, Seekable]++instance GObject BufferedInputStream where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_buffered_input_stream_get_type+    ++class GObject o => BufferedInputStreamK o+instance (GObject o, IsDescendantOf BufferedInputStream o) => BufferedInputStreamK o++toBufferedInputStream :: BufferedInputStreamK o => o -> IO BufferedInputStream+toBufferedInputStream = unsafeCastTo BufferedInputStream++noBufferedInputStream :: Maybe BufferedInputStream+noBufferedInputStream = Nothing++-- VVV Prop "buffer-size"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getBufferedInputStreamBufferSize :: (MonadIO m, BufferedInputStreamK o) => o -> m Word32+getBufferedInputStreamBufferSize obj = liftIO $ getObjectPropertyCUInt obj "buffer-size"++setBufferedInputStreamBufferSize :: (MonadIO m, BufferedInputStreamK o) => o -> Word32 -> m ()+setBufferedInputStreamBufferSize obj val = liftIO $ setObjectPropertyCUInt obj "buffer-size" val++constructBufferedInputStreamBufferSize :: Word32 -> IO ([Char], GValue)+constructBufferedInputStreamBufferSize val = constructObjectPropertyCUInt "buffer-size" val++data BufferedInputStreamBufferSizePropertyInfo+instance AttrInfo BufferedInputStreamBufferSizePropertyInfo where+    type AttrAllowedOps BufferedInputStreamBufferSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint BufferedInputStreamBufferSizePropertyInfo = (~) Word32+    type AttrBaseTypeConstraint BufferedInputStreamBufferSizePropertyInfo = BufferedInputStreamK+    type AttrGetType BufferedInputStreamBufferSizePropertyInfo = Word32+    type AttrLabel BufferedInputStreamBufferSizePropertyInfo = "BufferedInputStream::buffer-size"+    attrGet _ = getBufferedInputStreamBufferSize+    attrSet _ = setBufferedInputStreamBufferSize+    attrConstruct _ = constructBufferedInputStreamBufferSize++type instance AttributeList BufferedInputStream = BufferedInputStreamAttributeList+type BufferedInputStreamAttributeList = ('[ '("base-stream", FilterInputStreamBaseStreamPropertyInfo), '("buffer-size", BufferedInputStreamBufferSizePropertyInfo), '("close-base-stream", FilterInputStreamCloseBaseStreamPropertyInfo)] :: [(Symbol, *)])++type instance SignalList BufferedInputStream = BufferedInputStreamSignalList+type BufferedInputStreamSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method BufferedInputStream::new+-- method type : Constructor+-- Args : [Arg {argName = "base_stream", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "base_stream", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "BufferedInputStream"+-- throws : False+-- Skip return : False++foreign import ccall "g_buffered_input_stream_new" g_buffered_input_stream_new :: +    Ptr InputStream ->                      -- base_stream : TInterface "Gio" "InputStream"+    IO (Ptr BufferedInputStream)+++bufferedInputStreamNew ::+    (MonadIO m, InputStreamK a) =>+    a ->                                    -- base_stream+    m BufferedInputStream+bufferedInputStreamNew base_stream = liftIO $ do+    let base_stream' = unsafeManagedPtrCastPtr base_stream+    result <- g_buffered_input_stream_new base_stream'+    checkUnexpectedReturnNULL "g_buffered_input_stream_new" result+    result' <- (wrapObject BufferedInputStream) result+    touchManagedPtr base_stream+    return result'++-- method BufferedInputStream::new_sized+-- method type : Constructor+-- Args : [Arg {argName = "base_stream", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "base_stream", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "BufferedInputStream"+-- throws : False+-- Skip return : False++foreign import ccall "g_buffered_input_stream_new_sized" g_buffered_input_stream_new_sized :: +    Ptr InputStream ->                      -- base_stream : TInterface "Gio" "InputStream"+    Word64 ->                               -- size : TBasicType TUInt64+    IO (Ptr BufferedInputStream)+++bufferedInputStreamNewSized ::+    (MonadIO m, InputStreamK a) =>+    a ->                                    -- base_stream+    Word64 ->                               -- size+    m BufferedInputStream+bufferedInputStreamNewSized base_stream size = liftIO $ do+    let base_stream' = unsafeManagedPtrCastPtr base_stream+    result <- g_buffered_input_stream_new_sized base_stream' size+    checkUnexpectedReturnNULL "g_buffered_input_stream_new_sized" result+    result' <- (wrapObject BufferedInputStream) result+    touchManagedPtr base_stream+    return result'++-- method BufferedInputStream::fill+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "BufferedInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "count", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "BufferedInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "count", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : True+-- Skip return : False++foreign import ccall "g_buffered_input_stream_fill" g_buffered_input_stream_fill :: +    Ptr BufferedInputStream ->              -- _obj : TInterface "Gio" "BufferedInputStream"+    Int64 ->                                -- count : TBasicType TInt64+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO Int64+++bufferedInputStreamFill ::+    (MonadIO m, BufferedInputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Int64 ->                                -- count+    Maybe (b) ->                            -- cancellable+    m Int64+bufferedInputStreamFill _obj count cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_buffered_input_stream_fill _obj' count maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return result+     ) (do+        return ()+     )++-- method BufferedInputStream::fill_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "BufferedInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "count", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "BufferedInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "count", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_buffered_input_stream_fill_async" g_buffered_input_stream_fill_async :: +    Ptr BufferedInputStream ->              -- _obj : TInterface "Gio" "BufferedInputStream"+    Int64 ->                                -- count : TBasicType TInt64+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++bufferedInputStreamFillAsync ::+    (MonadIO m, BufferedInputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Int64 ->                                -- count+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+bufferedInputStreamFillAsync _obj count io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_buffered_input_stream_fill_async _obj' count io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method BufferedInputStream::fill_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "BufferedInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "BufferedInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : True+-- Skip return : False++foreign import ccall "g_buffered_input_stream_fill_finish" g_buffered_input_stream_fill_finish :: +    Ptr BufferedInputStream ->              -- _obj : TInterface "Gio" "BufferedInputStream"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO Int64+++bufferedInputStreamFillFinish ::+    (MonadIO m, BufferedInputStreamK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m Int64+bufferedInputStreamFillFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        result <- propagateGError $ g_buffered_input_stream_fill_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return result+     ) (do+        return ()+     )++-- method BufferedInputStream::get_available+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "BufferedInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "BufferedInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "g_buffered_input_stream_get_available" g_buffered_input_stream_get_available :: +    Ptr BufferedInputStream ->              -- _obj : TInterface "Gio" "BufferedInputStream"+    IO Word64+++bufferedInputStreamGetAvailable ::+    (MonadIO m, BufferedInputStreamK a) =>+    a ->                                    -- _obj+    m Word64+bufferedInputStreamGetAvailable _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_buffered_input_stream_get_available _obj'+    touchManagedPtr _obj+    return result++-- method BufferedInputStream::get_buffer_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "BufferedInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "BufferedInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "g_buffered_input_stream_get_buffer_size" g_buffered_input_stream_get_buffer_size :: +    Ptr BufferedInputStream ->              -- _obj : TInterface "Gio" "BufferedInputStream"+    IO Word64+++bufferedInputStreamGetBufferSize ::+    (MonadIO m, BufferedInputStreamK a) =>+    a ->                                    -- _obj+    m Word64+bufferedInputStreamGetBufferSize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_buffered_input_stream_get_buffer_size _obj'+    touchManagedPtr _obj+    return result++-- method BufferedInputStream::peek+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "BufferedInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 3 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "BufferedInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 3 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "g_buffered_input_stream_peek" g_buffered_input_stream_peek :: +    Ptr BufferedInputStream ->              -- _obj : TInterface "Gio" "BufferedInputStream"+    Ptr Word8 ->                            -- buffer : TCArray False (-1) 3 (TBasicType TUInt8)+    Word64 ->                               -- offset : TBasicType TUInt64+    Word64 ->                               -- count : TBasicType TUInt64+    IO Word64+++bufferedInputStreamPeek ::+    (MonadIO m, BufferedInputStreamK a) =>+    a ->                                    -- _obj+    ByteString ->                           -- buffer+    Word64 ->                               -- offset+    m Word64+bufferedInputStreamPeek _obj buffer offset = liftIO $ do+    let count = fromIntegral $ B.length buffer+    let _obj' = unsafeManagedPtrCastPtr _obj+    buffer' <- packByteString buffer+    result <- g_buffered_input_stream_peek _obj' buffer' offset count+    touchManagedPtr _obj+    freeMem buffer'+    return result++-- method BufferedInputStream::peek_buffer+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "BufferedInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : [Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "BufferedInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray False (-1) 1 (TBasicType TUInt8)+-- throws : False+-- Skip return : False++foreign import ccall "g_buffered_input_stream_peek_buffer" g_buffered_input_stream_peek_buffer :: +    Ptr BufferedInputStream ->              -- _obj : TInterface "Gio" "BufferedInputStream"+    Ptr Word64 ->                           -- count : TBasicType TUInt64+    IO (Ptr Word8)+++bufferedInputStreamPeekBuffer ::+    (MonadIO m, BufferedInputStreamK a) =>+    a ->                                    -- _obj+    m ByteString+bufferedInputStreamPeekBuffer _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    count <- allocMem :: IO (Ptr Word64)+    result <- g_buffered_input_stream_peek_buffer _obj' count+    count' <- peek count+    checkUnexpectedReturnNULL "g_buffered_input_stream_peek_buffer" result+    result' <- (unpackByteStringWithLength count') result+    touchManagedPtr _obj+    freeMem count+    return result'++-- method BufferedInputStream::read_byte+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "BufferedInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "BufferedInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : True+-- Skip return : False++foreign import ccall "g_buffered_input_stream_read_byte" g_buffered_input_stream_read_byte :: +    Ptr BufferedInputStream ->              -- _obj : TInterface "Gio" "BufferedInputStream"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO Int32+++bufferedInputStreamReadByte ::+    (MonadIO m, BufferedInputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m Int32+bufferedInputStreamReadByte _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_buffered_input_stream_read_byte _obj' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return result+     ) (do+        return ()+     )++-- method BufferedInputStream::set_buffer_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "BufferedInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "BufferedInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_buffered_input_stream_set_buffer_size" g_buffered_input_stream_set_buffer_size :: +    Ptr BufferedInputStream ->              -- _obj : TInterface "Gio" "BufferedInputStream"+    Word64 ->                               -- size : TBasicType TUInt64+    IO ()+++bufferedInputStreamSetBufferSize ::+    (MonadIO m, BufferedInputStreamK a) =>+    a ->                                    -- _obj+    Word64 ->                               -- size+    m ()+bufferedInputStreamSetBufferSize _obj size = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_buffered_input_stream_set_buffer_size _obj' size+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Objects/BufferedInputStream.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gio.Objects.BufferedInputStream where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype BufferedInputStream = BufferedInputStream (ForeignPtr BufferedInputStream)+instance GObject BufferedInputStream where+class GObject o => BufferedInputStreamK o+instance (GObject o, IsDescendantOf BufferedInputStream o) => BufferedInputStreamK o+data BufferedInputStreamBufferSizePropertyInfo
+ GI/Gio/Objects/BufferedOutputStream.hs view
@@ -0,0 +1,306 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.BufferedOutputStream+    ( ++-- * Exported types+    BufferedOutputStream(..)                ,+    BufferedOutputStreamK                   ,+    toBufferedOutputStream                  ,+    noBufferedOutputStream                  ,+++ -- * Methods+-- ** bufferedOutputStreamGetAutoGrow+    bufferedOutputStreamGetAutoGrow         ,+++-- ** bufferedOutputStreamGetBufferSize+    bufferedOutputStreamGetBufferSize       ,+++-- ** bufferedOutputStreamNew+    bufferedOutputStreamNew                 ,+++-- ** bufferedOutputStreamNewSized+    bufferedOutputStreamNewSized            ,+++-- ** bufferedOutputStreamSetAutoGrow+    bufferedOutputStreamSetAutoGrow         ,+++-- ** bufferedOutputStreamSetBufferSize+    bufferedOutputStreamSetBufferSize       ,+++++ -- * Properties+-- ** AutoGrow+    BufferedOutputStreamAutoGrowPropertyInfo,+    constructBufferedOutputStreamAutoGrow   ,+    getBufferedOutputStreamAutoGrow         ,+    setBufferedOutputStreamAutoGrow         ,+++-- ** BufferSize+    BufferedOutputStreamBufferSizePropertyInfo,+    constructBufferedOutputStreamBufferSize ,+    getBufferedOutputStreamBufferSize       ,+    setBufferedOutputStreamBufferSize       ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype BufferedOutputStream = BufferedOutputStream (ForeignPtr BufferedOutputStream)+foreign import ccall "g_buffered_output_stream_get_type"+    c_g_buffered_output_stream_get_type :: IO GType++type instance ParentTypes BufferedOutputStream = BufferedOutputStreamParentTypes+type BufferedOutputStreamParentTypes = '[FilterOutputStream, OutputStream, GObject.Object, Seekable]++instance GObject BufferedOutputStream where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_buffered_output_stream_get_type+    ++class GObject o => BufferedOutputStreamK o+instance (GObject o, IsDescendantOf BufferedOutputStream o) => BufferedOutputStreamK o++toBufferedOutputStream :: BufferedOutputStreamK o => o -> IO BufferedOutputStream+toBufferedOutputStream = unsafeCastTo BufferedOutputStream++noBufferedOutputStream :: Maybe BufferedOutputStream+noBufferedOutputStream = Nothing++-- VVV Prop "auto-grow"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getBufferedOutputStreamAutoGrow :: (MonadIO m, BufferedOutputStreamK o) => o -> m Bool+getBufferedOutputStreamAutoGrow obj = liftIO $ getObjectPropertyBool obj "auto-grow"++setBufferedOutputStreamAutoGrow :: (MonadIO m, BufferedOutputStreamK o) => o -> Bool -> m ()+setBufferedOutputStreamAutoGrow obj val = liftIO $ setObjectPropertyBool obj "auto-grow" val++constructBufferedOutputStreamAutoGrow :: Bool -> IO ([Char], GValue)+constructBufferedOutputStreamAutoGrow val = constructObjectPropertyBool "auto-grow" val++data BufferedOutputStreamAutoGrowPropertyInfo+instance AttrInfo BufferedOutputStreamAutoGrowPropertyInfo where+    type AttrAllowedOps BufferedOutputStreamAutoGrowPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint BufferedOutputStreamAutoGrowPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint BufferedOutputStreamAutoGrowPropertyInfo = BufferedOutputStreamK+    type AttrGetType BufferedOutputStreamAutoGrowPropertyInfo = Bool+    type AttrLabel BufferedOutputStreamAutoGrowPropertyInfo = "BufferedOutputStream::auto-grow"+    attrGet _ = getBufferedOutputStreamAutoGrow+    attrSet _ = setBufferedOutputStreamAutoGrow+    attrConstruct _ = constructBufferedOutputStreamAutoGrow++-- VVV Prop "buffer-size"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getBufferedOutputStreamBufferSize :: (MonadIO m, BufferedOutputStreamK o) => o -> m Word32+getBufferedOutputStreamBufferSize obj = liftIO $ getObjectPropertyCUInt obj "buffer-size"++setBufferedOutputStreamBufferSize :: (MonadIO m, BufferedOutputStreamK o) => o -> Word32 -> m ()+setBufferedOutputStreamBufferSize obj val = liftIO $ setObjectPropertyCUInt obj "buffer-size" val++constructBufferedOutputStreamBufferSize :: Word32 -> IO ([Char], GValue)+constructBufferedOutputStreamBufferSize val = constructObjectPropertyCUInt "buffer-size" val++data BufferedOutputStreamBufferSizePropertyInfo+instance AttrInfo BufferedOutputStreamBufferSizePropertyInfo where+    type AttrAllowedOps BufferedOutputStreamBufferSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint BufferedOutputStreamBufferSizePropertyInfo = (~) Word32+    type AttrBaseTypeConstraint BufferedOutputStreamBufferSizePropertyInfo = BufferedOutputStreamK+    type AttrGetType BufferedOutputStreamBufferSizePropertyInfo = Word32+    type AttrLabel BufferedOutputStreamBufferSizePropertyInfo = "BufferedOutputStream::buffer-size"+    attrGet _ = getBufferedOutputStreamBufferSize+    attrSet _ = setBufferedOutputStreamBufferSize+    attrConstruct _ = constructBufferedOutputStreamBufferSize++type instance AttributeList BufferedOutputStream = BufferedOutputStreamAttributeList+type BufferedOutputStreamAttributeList = ('[ '("auto-grow", BufferedOutputStreamAutoGrowPropertyInfo), '("base-stream", FilterOutputStreamBaseStreamPropertyInfo), '("buffer-size", BufferedOutputStreamBufferSizePropertyInfo), '("close-base-stream", FilterOutputStreamCloseBaseStreamPropertyInfo)] :: [(Symbol, *)])++type instance SignalList BufferedOutputStream = BufferedOutputStreamSignalList+type BufferedOutputStreamSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method BufferedOutputStream::new+-- method type : Constructor+-- Args : [Arg {argName = "base_stream", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "base_stream", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "BufferedOutputStream"+-- throws : False+-- Skip return : False++foreign import ccall "g_buffered_output_stream_new" g_buffered_output_stream_new :: +    Ptr OutputStream ->                     -- base_stream : TInterface "Gio" "OutputStream"+    IO (Ptr BufferedOutputStream)+++bufferedOutputStreamNew ::+    (MonadIO m, OutputStreamK a) =>+    a ->                                    -- base_stream+    m BufferedOutputStream+bufferedOutputStreamNew base_stream = liftIO $ do+    let base_stream' = unsafeManagedPtrCastPtr base_stream+    result <- g_buffered_output_stream_new base_stream'+    checkUnexpectedReturnNULL "g_buffered_output_stream_new" result+    result' <- (wrapObject BufferedOutputStream) result+    touchManagedPtr base_stream+    return result'++-- method BufferedOutputStream::new_sized+-- method type : Constructor+-- Args : [Arg {argName = "base_stream", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "base_stream", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "BufferedOutputStream"+-- throws : False+-- Skip return : False++foreign import ccall "g_buffered_output_stream_new_sized" g_buffered_output_stream_new_sized :: +    Ptr OutputStream ->                     -- base_stream : TInterface "Gio" "OutputStream"+    Word64 ->                               -- size : TBasicType TUInt64+    IO (Ptr BufferedOutputStream)+++bufferedOutputStreamNewSized ::+    (MonadIO m, OutputStreamK a) =>+    a ->                                    -- base_stream+    Word64 ->                               -- size+    m BufferedOutputStream+bufferedOutputStreamNewSized base_stream size = liftIO $ do+    let base_stream' = unsafeManagedPtrCastPtr base_stream+    result <- g_buffered_output_stream_new_sized base_stream' size+    checkUnexpectedReturnNULL "g_buffered_output_stream_new_sized" result+    result' <- (wrapObject BufferedOutputStream) result+    touchManagedPtr base_stream+    return result'++-- method BufferedOutputStream::get_auto_grow+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "BufferedOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "BufferedOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_buffered_output_stream_get_auto_grow" g_buffered_output_stream_get_auto_grow :: +    Ptr BufferedOutputStream ->             -- _obj : TInterface "Gio" "BufferedOutputStream"+    IO CInt+++bufferedOutputStreamGetAutoGrow ::+    (MonadIO m, BufferedOutputStreamK a) =>+    a ->                                    -- _obj+    m Bool+bufferedOutputStreamGetAutoGrow _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_buffered_output_stream_get_auto_grow _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method BufferedOutputStream::get_buffer_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "BufferedOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "BufferedOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "g_buffered_output_stream_get_buffer_size" g_buffered_output_stream_get_buffer_size :: +    Ptr BufferedOutputStream ->             -- _obj : TInterface "Gio" "BufferedOutputStream"+    IO Word64+++bufferedOutputStreamGetBufferSize ::+    (MonadIO m, BufferedOutputStreamK a) =>+    a ->                                    -- _obj+    m Word64+bufferedOutputStreamGetBufferSize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_buffered_output_stream_get_buffer_size _obj'+    touchManagedPtr _obj+    return result++-- method BufferedOutputStream::set_auto_grow+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "BufferedOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "auto_grow", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "BufferedOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "auto_grow", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_buffered_output_stream_set_auto_grow" g_buffered_output_stream_set_auto_grow :: +    Ptr BufferedOutputStream ->             -- _obj : TInterface "Gio" "BufferedOutputStream"+    CInt ->                                 -- auto_grow : TBasicType TBoolean+    IO ()+++bufferedOutputStreamSetAutoGrow ::+    (MonadIO m, BufferedOutputStreamK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- auto_grow+    m ()+bufferedOutputStreamSetAutoGrow _obj auto_grow = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let auto_grow' = (fromIntegral . fromEnum) auto_grow+    g_buffered_output_stream_set_auto_grow _obj' auto_grow'+    touchManagedPtr _obj+    return ()++-- method BufferedOutputStream::set_buffer_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "BufferedOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "BufferedOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_buffered_output_stream_set_buffer_size" g_buffered_output_stream_set_buffer_size :: +    Ptr BufferedOutputStream ->             -- _obj : TInterface "Gio" "BufferedOutputStream"+    Word64 ->                               -- size : TBasicType TUInt64+    IO ()+++bufferedOutputStreamSetBufferSize ::+    (MonadIO m, BufferedOutputStreamK a) =>+    a ->                                    -- _obj+    Word64 ->                               -- size+    m ()+bufferedOutputStreamSetBufferSize _obj size = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_buffered_output_stream_set_buffer_size _obj' size+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Objects/BufferedOutputStream.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gio.Objects.BufferedOutputStream where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype BufferedOutputStream = BufferedOutputStream (ForeignPtr BufferedOutputStream)+instance GObject BufferedOutputStream where+class GObject o => BufferedOutputStreamK o+instance (GObject o, IsDescendantOf BufferedOutputStream o) => BufferedOutputStreamK o+data BufferedOutputStreamAutoGrowPropertyInfo+data BufferedOutputStreamBufferSizePropertyInfo
+ GI/Gio/Objects/BytesIcon.hs view
@@ -0,0 +1,152 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.BytesIcon+    ( ++-- * Exported types+    BytesIcon(..)                           ,+    BytesIconK                              ,+    toBytesIcon                             ,+    noBytesIcon                             ,+++ -- * Methods+-- ** bytesIconGetBytes+    bytesIconGetBytes                       ,+++-- ** bytesIconNew+    bytesIconNew                            ,+++++ -- * Properties+-- ** Bytes+    BytesIconBytesPropertyInfo              ,+    constructBytesIconBytes                 ,+    getBytesIconBytes                       ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype BytesIcon = BytesIcon (ForeignPtr BytesIcon)+foreign import ccall "g_bytes_icon_get_type"+    c_g_bytes_icon_get_type :: IO GType++type instance ParentTypes BytesIcon = BytesIconParentTypes+type BytesIconParentTypes = '[GObject.Object, Icon, LoadableIcon]++instance GObject BytesIcon where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_bytes_icon_get_type+    ++class GObject o => BytesIconK o+instance (GObject o, IsDescendantOf BytesIcon o) => BytesIconK o++toBytesIcon :: BytesIconK o => o -> IO BytesIcon+toBytesIcon = unsafeCastTo BytesIcon++noBytesIcon :: Maybe BytesIcon+noBytesIcon = Nothing++-- VVV Prop "bytes"+   -- Type: TInterface "GLib" "Bytes"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getBytesIconBytes :: (MonadIO m, BytesIconK o) => o -> m GLib.Bytes+getBytesIconBytes obj = liftIO $ getObjectPropertyBoxed obj "bytes" GLib.Bytes++constructBytesIconBytes :: GLib.Bytes -> IO ([Char], GValue)+constructBytesIconBytes val = constructObjectPropertyBoxed "bytes" val++data BytesIconBytesPropertyInfo+instance AttrInfo BytesIconBytesPropertyInfo where+    type AttrAllowedOps BytesIconBytesPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint BytesIconBytesPropertyInfo = (~) GLib.Bytes+    type AttrBaseTypeConstraint BytesIconBytesPropertyInfo = BytesIconK+    type AttrGetType BytesIconBytesPropertyInfo = GLib.Bytes+    type AttrLabel BytesIconBytesPropertyInfo = "BytesIcon::bytes"+    attrGet _ = getBytesIconBytes+    attrSet _ = undefined+    attrConstruct _ = constructBytesIconBytes++type instance AttributeList BytesIcon = BytesIconAttributeList+type BytesIconAttributeList = ('[ '("bytes", BytesIconBytesPropertyInfo)] :: [(Symbol, *)])++type instance SignalList BytesIcon = BytesIconSignalList+type BytesIconSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method BytesIcon::new+-- method type : Constructor+-- Args : [Arg {argName = "bytes", argType = TInterface "GLib" "Bytes", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "bytes", argType = TInterface "GLib" "Bytes", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "BytesIcon"+-- throws : False+-- Skip return : False++foreign import ccall "g_bytes_icon_new" g_bytes_icon_new :: +    Ptr GLib.Bytes ->                       -- bytes : TInterface "GLib" "Bytes"+    IO (Ptr BytesIcon)+++bytesIconNew ::+    (MonadIO m) =>+    GLib.Bytes ->                           -- bytes+    m BytesIcon+bytesIconNew bytes = liftIO $ do+    let bytes' = unsafeManagedPtrGetPtr bytes+    result <- g_bytes_icon_new bytes'+    checkUnexpectedReturnNULL "g_bytes_icon_new" result+    result' <- (wrapObject BytesIcon) result+    touchManagedPtr bytes+    return result'++-- method BytesIcon::get_bytes+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "BytesIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "BytesIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GLib" "Bytes"+-- throws : False+-- Skip return : False++foreign import ccall "g_bytes_icon_get_bytes" g_bytes_icon_get_bytes :: +    Ptr BytesIcon ->                        -- _obj : TInterface "Gio" "BytesIcon"+    IO (Ptr GLib.Bytes)+++bytesIconGetBytes ::+    (MonadIO m, BytesIconK a) =>+    a ->                                    -- _obj+    m GLib.Bytes+bytesIconGetBytes _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_bytes_icon_get_bytes _obj'+    checkUnexpectedReturnNULL "g_bytes_icon_get_bytes" result+    result' <- (newBoxed GLib.Bytes) result+    touchManagedPtr _obj+    return result'++
+ GI/Gio/Objects/BytesIcon.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gio.Objects.BytesIcon where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype BytesIcon = BytesIcon (ForeignPtr BytesIcon)+instance GObject BytesIcon where+class GObject o => BytesIconK o+instance (GObject o, IsDescendantOf BytesIcon o) => BytesIconK o+data BytesIconBytesPropertyInfo
+ GI/Gio/Objects/Cancellable.hs view
@@ -0,0 +1,500 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.Cancellable+    ( ++-- * Exported types+    Cancellable(..)                         ,+    CancellableK                            ,+    toCancellable                           ,+    noCancellable                           ,+++ -- * Methods+-- ** cancellableCancel+    cancellableCancel                       ,+++-- ** cancellableConnect+    cancellableConnect                      ,+++-- ** cancellableDisconnect+    cancellableDisconnect                   ,+++-- ** cancellableGetCurrent+    cancellableGetCurrent                   ,+++-- ** cancellableGetFd+    cancellableGetFd                        ,+++-- ** cancellableIsCancelled+    cancellableIsCancelled                  ,+++-- ** cancellableMakePollfd+    cancellableMakePollfd                   ,+++-- ** cancellableNew+    cancellableNew                          ,+++-- ** cancellablePopCurrent+    cancellablePopCurrent                   ,+++-- ** cancellablePushCurrent+    cancellablePushCurrent                  ,+++-- ** cancellableReleaseFd+    cancellableReleaseFd                    ,+++-- ** cancellableReset+    cancellableReset                        ,+++-- ** cancellableSetErrorIfCancelled+    cancellableSetErrorIfCancelled          ,+++++ -- * Signals+-- ** Cancelled+    CancellableCancelledCallback            ,+    CancellableCancelledCallbackC           ,+    CancellableCancelledSignalInfo          ,+    afterCancellableCancelled               ,+    cancellableCancelledCallbackWrapper     ,+    cancellableCancelledClosure             ,+    mkCancellableCancelledCallback          ,+    noCancellableCancelledCallback          ,+    onCancellableCancelled                  ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype Cancellable = Cancellable (ForeignPtr Cancellable)+foreign import ccall "g_cancellable_get_type"+    c_g_cancellable_get_type :: IO GType++type instance ParentTypes Cancellable = CancellableParentTypes+type CancellableParentTypes = '[GObject.Object]++instance GObject Cancellable where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_cancellable_get_type+    ++class GObject o => CancellableK o+instance (GObject o, IsDescendantOf Cancellable o) => CancellableK o++toCancellable :: CancellableK o => o -> IO Cancellable+toCancellable = unsafeCastTo Cancellable++noCancellable :: Maybe Cancellable+noCancellable = Nothing++-- signal Cancellable::cancelled+type CancellableCancelledCallback =+    IO ()++noCancellableCancelledCallback :: Maybe CancellableCancelledCallback+noCancellableCancelledCallback = Nothing++type CancellableCancelledCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkCancellableCancelledCallback :: CancellableCancelledCallbackC -> IO (FunPtr CancellableCancelledCallbackC)++cancellableCancelledClosure :: CancellableCancelledCallback -> IO Closure+cancellableCancelledClosure cb = newCClosure =<< mkCancellableCancelledCallback wrapped+    where wrapped = cancellableCancelledCallbackWrapper cb++cancellableCancelledCallbackWrapper ::+    CancellableCancelledCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+cancellableCancelledCallbackWrapper _cb _ _ = do+    _cb ++onCancellableCancelled :: (GObject a, MonadIO m) => a -> CancellableCancelledCallback -> m SignalHandlerId+onCancellableCancelled obj cb = liftIO $ connectCancellableCancelled obj cb SignalConnectBefore+afterCancellableCancelled :: (GObject a, MonadIO m) => a -> CancellableCancelledCallback -> m SignalHandlerId+afterCancellableCancelled obj cb = connectCancellableCancelled obj cb SignalConnectAfter++connectCancellableCancelled :: (GObject a, MonadIO m) =>+                               a -> CancellableCancelledCallback -> SignalConnectMode -> m SignalHandlerId+connectCancellableCancelled obj cb after = liftIO $ do+    cb' <- mkCancellableCancelledCallback (cancellableCancelledCallbackWrapper cb)+    connectSignalFunPtr obj "cancelled" cb' after++type instance AttributeList Cancellable = CancellableAttributeList+type CancellableAttributeList = ('[ ] :: [(Symbol, *)])++data CancellableCancelledSignalInfo+instance SignalInfo CancellableCancelledSignalInfo where+    type HaskellCallbackType CancellableCancelledSignalInfo = CancellableCancelledCallback+    connectSignal _ = connectCancellableCancelled++type instance SignalList Cancellable = CancellableSignalList+type CancellableSignalList = ('[ '("cancelled", CancellableCancelledSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Cancellable::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gio" "Cancellable"+-- throws : False+-- Skip return : False++foreign import ccall "g_cancellable_new" g_cancellable_new :: +    IO (Ptr Cancellable)+++cancellableNew ::+    (MonadIO m) =>+    m Cancellable+cancellableNew  = liftIO $ do+    result <- g_cancellable_new+    checkUnexpectedReturnNULL "g_cancellable_new" result+    result' <- (wrapObject Cancellable) result+    return result'++-- method Cancellable::cancel+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_cancellable_cancel" g_cancellable_cancel :: +    Ptr Cancellable ->                      -- _obj : TInterface "Gio" "Cancellable"+    IO ()+++cancellableCancel ::+    (MonadIO m, CancellableK a) =>+    a ->                                    -- _obj+    m ()+cancellableCancel _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_cancellable_cancel _obj'+    touchManagedPtr _obj+    return ()++-- method Cancellable::connect+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "GObject" "Callback", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, transfer = TransferNothing},Arg {argName = "data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "data_destroy_func", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "GObject" "Callback", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, transfer = TransferNothing}]+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "g_cancellable_connect" g_cancellable_connect :: +    Ptr Cancellable ->                      -- _obj : TInterface "Gio" "Cancellable"+    FunPtr GObject.CallbackC ->             -- callback : TInterface "GObject" "Callback"+    Ptr () ->                               -- data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- data_destroy_func : TInterface "GLib" "DestroyNotify"+    IO Word64+++cancellableConnect ::+    (MonadIO m, CancellableK a) =>+    a ->                                    -- _obj+    GObject.Callback ->                     -- callback+    m Word64+cancellableConnect _obj callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    callback' <- GObject.mkCallback (GObject.callbackWrapper Nothing callback)+    let data_ = castFunPtrToPtr callback'+    let data_destroy_func = safeFreeFunPtrPtr+    result <- g_cancellable_connect _obj' callback' data_ data_destroy_func+    touchManagedPtr _obj+    return result++-- method Cancellable::disconnect+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "handler_id", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "handler_id", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_cancellable_disconnect" g_cancellable_disconnect :: +    Ptr Cancellable ->                      -- _obj : TInterface "Gio" "Cancellable"+    Word64 ->                               -- handler_id : TBasicType TUInt64+    IO ()+++cancellableDisconnect ::+    (MonadIO m, CancellableK a) =>+    a ->                                    -- _obj+    Word64 ->                               -- handler_id+    m ()+cancellableDisconnect _obj handler_id = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_cancellable_disconnect _obj' handler_id+    touchManagedPtr _obj+    return ()++-- method Cancellable::get_fd+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_cancellable_get_fd" g_cancellable_get_fd :: +    Ptr Cancellable ->                      -- _obj : TInterface "Gio" "Cancellable"+    IO Int32+++cancellableGetFd ::+    (MonadIO m, CancellableK a) =>+    a ->                                    -- _obj+    m Int32+cancellableGetFd _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_cancellable_get_fd _obj'+    touchManagedPtr _obj+    return result++-- method Cancellable::is_cancelled+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_cancellable_is_cancelled" g_cancellable_is_cancelled :: +    Ptr Cancellable ->                      -- _obj : TInterface "Gio" "Cancellable"+    IO CInt+++cancellableIsCancelled ::+    (MonadIO m, CancellableK a) =>+    a ->                                    -- _obj+    m Bool+cancellableIsCancelled _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_cancellable_is_cancelled _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Cancellable::make_pollfd+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pollfd", argType = TInterface "GLib" "PollFD", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pollfd", argType = TInterface "GLib" "PollFD", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_cancellable_make_pollfd" g_cancellable_make_pollfd :: +    Ptr Cancellable ->                      -- _obj : TInterface "Gio" "Cancellable"+    Ptr GLib.PollFD ->                      -- pollfd : TInterface "GLib" "PollFD"+    IO CInt+++cancellableMakePollfd ::+    (MonadIO m, CancellableK a) =>+    a ->                                    -- _obj+    GLib.PollFD ->                          -- pollfd+    m Bool+cancellableMakePollfd _obj pollfd = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let pollfd' = unsafeManagedPtrGetPtr pollfd+    result <- g_cancellable_make_pollfd _obj' pollfd'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr pollfd+    return result'++-- method Cancellable::pop_current+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_cancellable_pop_current" g_cancellable_pop_current :: +    Ptr Cancellable ->                      -- _obj : TInterface "Gio" "Cancellable"+    IO ()+++cancellablePopCurrent ::+    (MonadIO m, CancellableK a) =>+    a ->                                    -- _obj+    m ()+cancellablePopCurrent _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_cancellable_pop_current _obj'+    touchManagedPtr _obj+    return ()++-- method Cancellable::push_current+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_cancellable_push_current" g_cancellable_push_current :: +    Ptr Cancellable ->                      -- _obj : TInterface "Gio" "Cancellable"+    IO ()+++cancellablePushCurrent ::+    (MonadIO m, CancellableK a) =>+    a ->                                    -- _obj+    m ()+cancellablePushCurrent _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_cancellable_push_current _obj'+    touchManagedPtr _obj+    return ()++-- method Cancellable::release_fd+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_cancellable_release_fd" g_cancellable_release_fd :: +    Ptr Cancellable ->                      -- _obj : TInterface "Gio" "Cancellable"+    IO ()+++cancellableReleaseFd ::+    (MonadIO m, CancellableK a) =>+    a ->                                    -- _obj+    m ()+cancellableReleaseFd _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_cancellable_release_fd _obj'+    touchManagedPtr _obj+    return ()++-- method Cancellable::reset+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_cancellable_reset" g_cancellable_reset :: +    Ptr Cancellable ->                      -- _obj : TInterface "Gio" "Cancellable"+    IO ()+++cancellableReset ::+    (MonadIO m, CancellableK a) =>+    a ->                                    -- _obj+    m ()+cancellableReset _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_cancellable_reset _obj'+    touchManagedPtr _obj+    return ()++-- method Cancellable::set_error_if_cancelled+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_cancellable_set_error_if_cancelled" g_cancellable_set_error_if_cancelled :: +    Ptr Cancellable ->                      -- _obj : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++cancellableSetErrorIfCancelled ::+    (MonadIO m, CancellableK a) =>+    a ->                                    -- _obj+    m ()+cancellableSetErrorIfCancelled _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    onException (do+        _ <- propagateGError $ g_cancellable_set_error_if_cancelled _obj'+        touchManagedPtr _obj+        return ()+     ) (do+        return ()+     )++-- method Cancellable::get_current+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gio" "Cancellable"+-- throws : False+-- Skip return : False++foreign import ccall "g_cancellable_get_current" g_cancellable_get_current :: +    IO (Ptr Cancellable)+++cancellableGetCurrent ::+    (MonadIO m) =>+    m Cancellable+cancellableGetCurrent  = liftIO $ do+    result <- g_cancellable_get_current+    checkUnexpectedReturnNULL "g_cancellable_get_current" result+    result' <- (newObject Cancellable) result+    return result'++
+ GI/Gio/Objects/Cancellable.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gio.Objects.Cancellable where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Cancellable = Cancellable (ForeignPtr Cancellable)+instance GObject Cancellable where+class GObject o => CancellableK o+instance (GObject o, IsDescendantOf Cancellable o) => CancellableK o+data CancellableCancelledSignalInfo
+ GI/Gio/Objects/CharsetConverter.hs view
@@ -0,0 +1,277 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.CharsetConverter+    ( ++-- * Exported types+    CharsetConverter(..)                    ,+    CharsetConverterK                       ,+    toCharsetConverter                      ,+    noCharsetConverter                      ,+++ -- * Methods+-- ** charsetConverterGetNumFallbacks+    charsetConverterGetNumFallbacks         ,+++-- ** charsetConverterGetUseFallback+    charsetConverterGetUseFallback          ,+++-- ** charsetConverterNew+    charsetConverterNew                     ,+++-- ** charsetConverterSetUseFallback+    charsetConverterSetUseFallback          ,+++++ -- * Properties+-- ** FromCharset+    CharsetConverterFromCharsetPropertyInfo ,+    constructCharsetConverterFromCharset    ,+    getCharsetConverterFromCharset          ,+++-- ** ToCharset+    CharsetConverterToCharsetPropertyInfo   ,+    constructCharsetConverterToCharset      ,+    getCharsetConverterToCharset            ,+++-- ** UseFallback+    CharsetConverterUseFallbackPropertyInfo ,+    constructCharsetConverterUseFallback    ,+    getCharsetConverterUseFallback          ,+    setCharsetConverterUseFallback          ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype CharsetConverter = CharsetConverter (ForeignPtr CharsetConverter)+foreign import ccall "g_charset_converter_get_type"+    c_g_charset_converter_get_type :: IO GType++type instance ParentTypes CharsetConverter = CharsetConverterParentTypes+type CharsetConverterParentTypes = '[GObject.Object, Converter, Initable]++instance GObject CharsetConverter where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_charset_converter_get_type+    ++class GObject o => CharsetConverterK o+instance (GObject o, IsDescendantOf CharsetConverter o) => CharsetConverterK o++toCharsetConverter :: CharsetConverterK o => o -> IO CharsetConverter+toCharsetConverter = unsafeCastTo CharsetConverter++noCharsetConverter :: Maybe CharsetConverter+noCharsetConverter = Nothing++-- VVV Prop "from-charset"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getCharsetConverterFromCharset :: (MonadIO m, CharsetConverterK o) => o -> m T.Text+getCharsetConverterFromCharset obj = liftIO $ getObjectPropertyString obj "from-charset"++constructCharsetConverterFromCharset :: T.Text -> IO ([Char], GValue)+constructCharsetConverterFromCharset val = constructObjectPropertyString "from-charset" val++data CharsetConverterFromCharsetPropertyInfo+instance AttrInfo CharsetConverterFromCharsetPropertyInfo where+    type AttrAllowedOps CharsetConverterFromCharsetPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CharsetConverterFromCharsetPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint CharsetConverterFromCharsetPropertyInfo = CharsetConverterK+    type AttrGetType CharsetConverterFromCharsetPropertyInfo = T.Text+    type AttrLabel CharsetConverterFromCharsetPropertyInfo = "CharsetConverter::from-charset"+    attrGet _ = getCharsetConverterFromCharset+    attrSet _ = undefined+    attrConstruct _ = constructCharsetConverterFromCharset++-- VVV Prop "to-charset"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getCharsetConverterToCharset :: (MonadIO m, CharsetConverterK o) => o -> m T.Text+getCharsetConverterToCharset obj = liftIO $ getObjectPropertyString obj "to-charset"++constructCharsetConverterToCharset :: T.Text -> IO ([Char], GValue)+constructCharsetConverterToCharset val = constructObjectPropertyString "to-charset" val++data CharsetConverterToCharsetPropertyInfo+instance AttrInfo CharsetConverterToCharsetPropertyInfo where+    type AttrAllowedOps CharsetConverterToCharsetPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CharsetConverterToCharsetPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint CharsetConverterToCharsetPropertyInfo = CharsetConverterK+    type AttrGetType CharsetConverterToCharsetPropertyInfo = T.Text+    type AttrLabel CharsetConverterToCharsetPropertyInfo = "CharsetConverter::to-charset"+    attrGet _ = getCharsetConverterToCharset+    attrSet _ = undefined+    attrConstruct _ = constructCharsetConverterToCharset++-- VVV Prop "use-fallback"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getCharsetConverterUseFallback :: (MonadIO m, CharsetConverterK o) => o -> m Bool+getCharsetConverterUseFallback obj = liftIO $ getObjectPropertyBool obj "use-fallback"++setCharsetConverterUseFallback :: (MonadIO m, CharsetConverterK o) => o -> Bool -> m ()+setCharsetConverterUseFallback obj val = liftIO $ setObjectPropertyBool obj "use-fallback" val++constructCharsetConverterUseFallback :: Bool -> IO ([Char], GValue)+constructCharsetConverterUseFallback val = constructObjectPropertyBool "use-fallback" val++data CharsetConverterUseFallbackPropertyInfo+instance AttrInfo CharsetConverterUseFallbackPropertyInfo where+    type AttrAllowedOps CharsetConverterUseFallbackPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CharsetConverterUseFallbackPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CharsetConverterUseFallbackPropertyInfo = CharsetConverterK+    type AttrGetType CharsetConverterUseFallbackPropertyInfo = Bool+    type AttrLabel CharsetConverterUseFallbackPropertyInfo = "CharsetConverter::use-fallback"+    attrGet _ = getCharsetConverterUseFallback+    attrSet _ = setCharsetConverterUseFallback+    attrConstruct _ = constructCharsetConverterUseFallback++type instance AttributeList CharsetConverter = CharsetConverterAttributeList+type CharsetConverterAttributeList = ('[ '("from-charset", CharsetConverterFromCharsetPropertyInfo), '("to-charset", CharsetConverterToCharsetPropertyInfo), '("use-fallback", CharsetConverterUseFallbackPropertyInfo)] :: [(Symbol, *)])++type instance SignalList CharsetConverter = CharsetConverterSignalList+type CharsetConverterSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method CharsetConverter::new+-- method type : Constructor+-- Args : [Arg {argName = "to_charset", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "from_charset", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "to_charset", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "from_charset", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "CharsetConverter"+-- throws : True+-- Skip return : False++foreign import ccall "g_charset_converter_new" g_charset_converter_new :: +    CString ->                              -- to_charset : TBasicType TUTF8+    CString ->                              -- from_charset : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr CharsetConverter)+++charsetConverterNew ::+    (MonadIO m) =>+    T.Text ->                               -- to_charset+    T.Text ->                               -- from_charset+    m CharsetConverter+charsetConverterNew to_charset from_charset = liftIO $ do+    to_charset' <- textToCString to_charset+    from_charset' <- textToCString from_charset+    onException (do+        result <- propagateGError $ g_charset_converter_new to_charset' from_charset'+        checkUnexpectedReturnNULL "g_charset_converter_new" result+        result' <- (wrapObject CharsetConverter) result+        freeMem to_charset'+        freeMem from_charset'+        return result'+     ) (do+        freeMem to_charset'+        freeMem from_charset'+     )++-- method CharsetConverter::get_num_fallbacks+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "CharsetConverter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "CharsetConverter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_charset_converter_get_num_fallbacks" g_charset_converter_get_num_fallbacks :: +    Ptr CharsetConverter ->                 -- _obj : TInterface "Gio" "CharsetConverter"+    IO Word32+++charsetConverterGetNumFallbacks ::+    (MonadIO m, CharsetConverterK a) =>+    a ->                                    -- _obj+    m Word32+charsetConverterGetNumFallbacks _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_charset_converter_get_num_fallbacks _obj'+    touchManagedPtr _obj+    return result++-- method CharsetConverter::get_use_fallback+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "CharsetConverter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "CharsetConverter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_charset_converter_get_use_fallback" g_charset_converter_get_use_fallback :: +    Ptr CharsetConverter ->                 -- _obj : TInterface "Gio" "CharsetConverter"+    IO CInt+++charsetConverterGetUseFallback ::+    (MonadIO m, CharsetConverterK a) =>+    a ->                                    -- _obj+    m Bool+charsetConverterGetUseFallback _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_charset_converter_get_use_fallback _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method CharsetConverter::set_use_fallback+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "CharsetConverter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_fallback", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "CharsetConverter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_fallback", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_charset_converter_set_use_fallback" g_charset_converter_set_use_fallback :: +    Ptr CharsetConverter ->                 -- _obj : TInterface "Gio" "CharsetConverter"+    CInt ->                                 -- use_fallback : TBasicType TBoolean+    IO ()+++charsetConverterSetUseFallback ::+    (MonadIO m, CharsetConverterK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- use_fallback+    m ()+charsetConverterSetUseFallback _obj use_fallback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let use_fallback' = (fromIntegral . fromEnum) use_fallback+    g_charset_converter_set_use_fallback _obj' use_fallback'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Objects/CharsetConverter.hs-boot view
@@ -0,0 +1,16 @@+module GI.Gio.Objects.CharsetConverter where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype CharsetConverter = CharsetConverter (ForeignPtr CharsetConverter)+instance GObject CharsetConverter where+class GObject o => CharsetConverterK o+instance (GObject o, IsDescendantOf CharsetConverter o) => CharsetConverterK o+data CharsetConverterFromCharsetPropertyInfo+data CharsetConverterToCharsetPropertyInfo+data CharsetConverterUseFallbackPropertyInfo
+ GI/Gio/Objects/ConverterInputStream.hs view
@@ -0,0 +1,155 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.ConverterInputStream+    ( ++-- * Exported types+    ConverterInputStream(..)                ,+    ConverterInputStreamK                   ,+    toConverterInputStream                  ,+    noConverterInputStream                  ,+++ -- * Methods+-- ** converterInputStreamGetConverter+    converterInputStreamGetConverter        ,+++-- ** converterInputStreamNew+    converterInputStreamNew                 ,+++++ -- * Properties+-- ** Converter+    ConverterInputStreamConverterPropertyInfo,+    constructConverterInputStreamConverter  ,+    getConverterInputStreamConverter        ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype ConverterInputStream = ConverterInputStream (ForeignPtr ConverterInputStream)+foreign import ccall "g_converter_input_stream_get_type"+    c_g_converter_input_stream_get_type :: IO GType++type instance ParentTypes ConverterInputStream = ConverterInputStreamParentTypes+type ConverterInputStreamParentTypes = '[FilterInputStream, InputStream, GObject.Object, PollableInputStream]++instance GObject ConverterInputStream where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_converter_input_stream_get_type+    ++class GObject o => ConverterInputStreamK o+instance (GObject o, IsDescendantOf ConverterInputStream o) => ConverterInputStreamK o++toConverterInputStream :: ConverterInputStreamK o => o -> IO ConverterInputStream+toConverterInputStream = unsafeCastTo ConverterInputStream++noConverterInputStream :: Maybe ConverterInputStream+noConverterInputStream = Nothing++-- VVV Prop "converter"+   -- Type: TInterface "Gio" "Converter"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getConverterInputStreamConverter :: (MonadIO m, ConverterInputStreamK o) => o -> m Converter+getConverterInputStreamConverter obj = liftIO $ getObjectPropertyObject obj "converter" Converter++constructConverterInputStreamConverter :: (ConverterK a) => a -> IO ([Char], GValue)+constructConverterInputStreamConverter val = constructObjectPropertyObject "converter" val++data ConverterInputStreamConverterPropertyInfo+instance AttrInfo ConverterInputStreamConverterPropertyInfo where+    type AttrAllowedOps ConverterInputStreamConverterPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ConverterInputStreamConverterPropertyInfo = ConverterK+    type AttrBaseTypeConstraint ConverterInputStreamConverterPropertyInfo = ConverterInputStreamK+    type AttrGetType ConverterInputStreamConverterPropertyInfo = Converter+    type AttrLabel ConverterInputStreamConverterPropertyInfo = "ConverterInputStream::converter"+    attrGet _ = getConverterInputStreamConverter+    attrSet _ = undefined+    attrConstruct _ = constructConverterInputStreamConverter++type instance AttributeList ConverterInputStream = ConverterInputStreamAttributeList+type ConverterInputStreamAttributeList = ('[ '("base-stream", FilterInputStreamBaseStreamPropertyInfo), '("close-base-stream", FilterInputStreamCloseBaseStreamPropertyInfo), '("converter", ConverterInputStreamConverterPropertyInfo)] :: [(Symbol, *)])++type instance SignalList ConverterInputStream = ConverterInputStreamSignalList+type ConverterInputStreamSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method ConverterInputStream::new+-- method type : Constructor+-- Args : [Arg {argName = "base_stream", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "converter", argType = TInterface "Gio" "Converter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "base_stream", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "converter", argType = TInterface "Gio" "Converter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "ConverterInputStream"+-- throws : False+-- Skip return : False++foreign import ccall "g_converter_input_stream_new" g_converter_input_stream_new :: +    Ptr InputStream ->                      -- base_stream : TInterface "Gio" "InputStream"+    Ptr Converter ->                        -- converter : TInterface "Gio" "Converter"+    IO (Ptr ConverterInputStream)+++converterInputStreamNew ::+    (MonadIO m, InputStreamK a, ConverterK b) =>+    a ->                                    -- base_stream+    b ->                                    -- converter+    m ConverterInputStream+converterInputStreamNew base_stream converter = liftIO $ do+    let base_stream' = unsafeManagedPtrCastPtr base_stream+    let converter' = unsafeManagedPtrCastPtr converter+    result <- g_converter_input_stream_new base_stream' converter'+    checkUnexpectedReturnNULL "g_converter_input_stream_new" result+    result' <- (wrapObject ConverterInputStream) result+    touchManagedPtr base_stream+    touchManagedPtr converter+    return result'++-- method ConverterInputStream::get_converter+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ConverterInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ConverterInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Converter"+-- throws : False+-- Skip return : False++foreign import ccall "g_converter_input_stream_get_converter" g_converter_input_stream_get_converter :: +    Ptr ConverterInputStream ->             -- _obj : TInterface "Gio" "ConverterInputStream"+    IO (Ptr Converter)+++converterInputStreamGetConverter ::+    (MonadIO m, ConverterInputStreamK a) =>+    a ->                                    -- _obj+    m Converter+converterInputStreamGetConverter _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_converter_input_stream_get_converter _obj'+    checkUnexpectedReturnNULL "g_converter_input_stream_get_converter" result+    result' <- (newObject Converter) result+    touchManagedPtr _obj+    return result'++
+ GI/Gio/Objects/ConverterInputStream.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gio.Objects.ConverterInputStream where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype ConverterInputStream = ConverterInputStream (ForeignPtr ConverterInputStream)+instance GObject ConverterInputStream where+class GObject o => ConverterInputStreamK o+instance (GObject o, IsDescendantOf ConverterInputStream o) => ConverterInputStreamK o+data ConverterInputStreamConverterPropertyInfo
+ GI/Gio/Objects/ConverterOutputStream.hs view
@@ -0,0 +1,155 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.ConverterOutputStream+    ( ++-- * Exported types+    ConverterOutputStream(..)               ,+    ConverterOutputStreamK                  ,+    toConverterOutputStream                 ,+    noConverterOutputStream                 ,+++ -- * Methods+-- ** converterOutputStreamGetConverter+    converterOutputStreamGetConverter       ,+++-- ** converterOutputStreamNew+    converterOutputStreamNew                ,+++++ -- * Properties+-- ** Converter+    ConverterOutputStreamConverterPropertyInfo,+    constructConverterOutputStreamConverter ,+    getConverterOutputStreamConverter       ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype ConverterOutputStream = ConverterOutputStream (ForeignPtr ConverterOutputStream)+foreign import ccall "g_converter_output_stream_get_type"+    c_g_converter_output_stream_get_type :: IO GType++type instance ParentTypes ConverterOutputStream = ConverterOutputStreamParentTypes+type ConverterOutputStreamParentTypes = '[FilterOutputStream, OutputStream, GObject.Object, PollableOutputStream]++instance GObject ConverterOutputStream where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_converter_output_stream_get_type+    ++class GObject o => ConverterOutputStreamK o+instance (GObject o, IsDescendantOf ConverterOutputStream o) => ConverterOutputStreamK o++toConverterOutputStream :: ConverterOutputStreamK o => o -> IO ConverterOutputStream+toConverterOutputStream = unsafeCastTo ConverterOutputStream++noConverterOutputStream :: Maybe ConverterOutputStream+noConverterOutputStream = Nothing++-- VVV Prop "converter"+   -- Type: TInterface "Gio" "Converter"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getConverterOutputStreamConverter :: (MonadIO m, ConverterOutputStreamK o) => o -> m Converter+getConverterOutputStreamConverter obj = liftIO $ getObjectPropertyObject obj "converter" Converter++constructConverterOutputStreamConverter :: (ConverterK a) => a -> IO ([Char], GValue)+constructConverterOutputStreamConverter val = constructObjectPropertyObject "converter" val++data ConverterOutputStreamConverterPropertyInfo+instance AttrInfo ConverterOutputStreamConverterPropertyInfo where+    type AttrAllowedOps ConverterOutputStreamConverterPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ConverterOutputStreamConverterPropertyInfo = ConverterK+    type AttrBaseTypeConstraint ConverterOutputStreamConverterPropertyInfo = ConverterOutputStreamK+    type AttrGetType ConverterOutputStreamConverterPropertyInfo = Converter+    type AttrLabel ConverterOutputStreamConverterPropertyInfo = "ConverterOutputStream::converter"+    attrGet _ = getConverterOutputStreamConverter+    attrSet _ = undefined+    attrConstruct _ = constructConverterOutputStreamConverter++type instance AttributeList ConverterOutputStream = ConverterOutputStreamAttributeList+type ConverterOutputStreamAttributeList = ('[ '("base-stream", FilterOutputStreamBaseStreamPropertyInfo), '("close-base-stream", FilterOutputStreamCloseBaseStreamPropertyInfo), '("converter", ConverterOutputStreamConverterPropertyInfo)] :: [(Symbol, *)])++type instance SignalList ConverterOutputStream = ConverterOutputStreamSignalList+type ConverterOutputStreamSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method ConverterOutputStream::new+-- method type : Constructor+-- Args : [Arg {argName = "base_stream", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "converter", argType = TInterface "Gio" "Converter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "base_stream", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "converter", argType = TInterface "Gio" "Converter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "ConverterOutputStream"+-- throws : False+-- Skip return : False++foreign import ccall "g_converter_output_stream_new" g_converter_output_stream_new :: +    Ptr OutputStream ->                     -- base_stream : TInterface "Gio" "OutputStream"+    Ptr Converter ->                        -- converter : TInterface "Gio" "Converter"+    IO (Ptr ConverterOutputStream)+++converterOutputStreamNew ::+    (MonadIO m, OutputStreamK a, ConverterK b) =>+    a ->                                    -- base_stream+    b ->                                    -- converter+    m ConverterOutputStream+converterOutputStreamNew base_stream converter = liftIO $ do+    let base_stream' = unsafeManagedPtrCastPtr base_stream+    let converter' = unsafeManagedPtrCastPtr converter+    result <- g_converter_output_stream_new base_stream' converter'+    checkUnexpectedReturnNULL "g_converter_output_stream_new" result+    result' <- (wrapObject ConverterOutputStream) result+    touchManagedPtr base_stream+    touchManagedPtr converter+    return result'++-- method ConverterOutputStream::get_converter+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ConverterOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ConverterOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Converter"+-- throws : False+-- Skip return : False++foreign import ccall "g_converter_output_stream_get_converter" g_converter_output_stream_get_converter :: +    Ptr ConverterOutputStream ->            -- _obj : TInterface "Gio" "ConverterOutputStream"+    IO (Ptr Converter)+++converterOutputStreamGetConverter ::+    (MonadIO m, ConverterOutputStreamK a) =>+    a ->                                    -- _obj+    m Converter+converterOutputStreamGetConverter _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_converter_output_stream_get_converter _obj'+    checkUnexpectedReturnNULL "g_converter_output_stream_get_converter" result+    result' <- (newObject Converter) result+    touchManagedPtr _obj+    return result'++
+ GI/Gio/Objects/ConverterOutputStream.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gio.Objects.ConverterOutputStream where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype ConverterOutputStream = ConverterOutputStream (ForeignPtr ConverterOutputStream)+instance GObject ConverterOutputStream where+class GObject o => ConverterOutputStreamK o+instance (GObject o, IsDescendantOf ConverterOutputStream o) => ConverterOutputStreamK o+data ConverterOutputStreamConverterPropertyInfo
+ GI/Gio/Objects/Credentials.hs view
@@ -0,0 +1,289 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.Credentials+    ( ++-- * Exported types+    Credentials(..)                         ,+    CredentialsK                            ,+    toCredentials                           ,+    noCredentials                           ,+++ -- * Methods+-- ** credentialsGetUnixPid+    credentialsGetUnixPid                   ,+++-- ** credentialsGetUnixUser+    credentialsGetUnixUser                  ,+++-- ** credentialsIsSameUser+    credentialsIsSameUser                   ,+++-- ** credentialsNew+    credentialsNew                          ,+++-- ** credentialsSetNative+    credentialsSetNative                    ,+++-- ** credentialsSetUnixUser+    credentialsSetUnixUser                  ,+++-- ** credentialsToString+    credentialsToString                     ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype Credentials = Credentials (ForeignPtr Credentials)+foreign import ccall "g_credentials_get_type"+    c_g_credentials_get_type :: IO GType++type instance ParentTypes Credentials = CredentialsParentTypes+type CredentialsParentTypes = '[GObject.Object]++instance GObject Credentials where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_credentials_get_type+    ++class GObject o => CredentialsK o+instance (GObject o, IsDescendantOf Credentials o) => CredentialsK o++toCredentials :: CredentialsK o => o -> IO Credentials+toCredentials = unsafeCastTo Credentials++noCredentials :: Maybe Credentials+noCredentials = Nothing++type instance AttributeList Credentials = CredentialsAttributeList+type CredentialsAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList Credentials = CredentialsSignalList+type CredentialsSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Credentials::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gio" "Credentials"+-- throws : False+-- Skip return : False++foreign import ccall "g_credentials_new" g_credentials_new :: +    IO (Ptr Credentials)+++credentialsNew ::+    (MonadIO m) =>+    m Credentials+credentialsNew  = liftIO $ do+    result <- g_credentials_new+    checkUnexpectedReturnNULL "g_credentials_new" result+    result' <- (wrapObject Credentials) result+    return result'++-- method Credentials::get_unix_pid+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Credentials", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Credentials", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : True+-- Skip return : False++foreign import ccall "g_credentials_get_unix_pid" g_credentials_get_unix_pid :: +    Ptr Credentials ->                      -- _obj : TInterface "Gio" "Credentials"+    Ptr (Ptr GError) ->                     -- error+    IO Int32+++credentialsGetUnixPid ::+    (MonadIO m, CredentialsK a) =>+    a ->                                    -- _obj+    m Int32+credentialsGetUnixPid _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    onException (do+        result <- propagateGError $ g_credentials_get_unix_pid _obj'+        touchManagedPtr _obj+        return result+     ) (do+        return ()+     )++-- method Credentials::get_unix_user+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Credentials", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Credentials", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : True+-- Skip return : False++foreign import ccall "g_credentials_get_unix_user" g_credentials_get_unix_user :: +    Ptr Credentials ->                      -- _obj : TInterface "Gio" "Credentials"+    Ptr (Ptr GError) ->                     -- error+    IO Word32+++credentialsGetUnixUser ::+    (MonadIO m, CredentialsK a) =>+    a ->                                    -- _obj+    m Word32+credentialsGetUnixUser _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    onException (do+        result <- propagateGError $ g_credentials_get_unix_user _obj'+        touchManagedPtr _obj+        return result+     ) (do+        return ()+     )++-- method Credentials::is_same_user+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Credentials", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "other_credentials", argType = TInterface "Gio" "Credentials", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Credentials", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "other_credentials", argType = TInterface "Gio" "Credentials", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_credentials_is_same_user" g_credentials_is_same_user :: +    Ptr Credentials ->                      -- _obj : TInterface "Gio" "Credentials"+    Ptr Credentials ->                      -- other_credentials : TInterface "Gio" "Credentials"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++credentialsIsSameUser ::+    (MonadIO m, CredentialsK a, CredentialsK b) =>+    a ->                                    -- _obj+    b ->                                    -- other_credentials+    m ()+credentialsIsSameUser _obj other_credentials = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let other_credentials' = unsafeManagedPtrCastPtr other_credentials+    onException (do+        _ <- propagateGError $ g_credentials_is_same_user _obj' other_credentials'+        touchManagedPtr _obj+        touchManagedPtr other_credentials+        return ()+     ) (do+        return ()+     )++-- method Credentials::set_native+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Credentials", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "native_type", argType = TInterface "Gio" "CredentialsType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "native", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Credentials", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "native_type", argType = TInterface "Gio" "CredentialsType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "native", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_credentials_set_native" g_credentials_set_native :: +    Ptr Credentials ->                      -- _obj : TInterface "Gio" "Credentials"+    CUInt ->                                -- native_type : TInterface "Gio" "CredentialsType"+    Ptr () ->                               -- native : TBasicType TVoid+    IO ()+++credentialsSetNative ::+    (MonadIO m, CredentialsK a) =>+    a ->                                    -- _obj+    CredentialsType ->                      -- native_type+    Ptr () ->                               -- native+    m ()+credentialsSetNative _obj native_type native = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let native_type' = (fromIntegral . fromEnum) native_type+    g_credentials_set_native _obj' native_type' native+    touchManagedPtr _obj+    return ()++-- method Credentials::set_unix_user+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Credentials", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "uid", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Credentials", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "uid", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_credentials_set_unix_user" g_credentials_set_unix_user :: +    Ptr Credentials ->                      -- _obj : TInterface "Gio" "Credentials"+    Word32 ->                               -- uid : TBasicType TUInt32+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++credentialsSetUnixUser ::+    (MonadIO m, CredentialsK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- uid+    m ()+credentialsSetUnixUser _obj uid = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    onException (do+        _ <- propagateGError $ g_credentials_set_unix_user _obj' uid+        touchManagedPtr _obj+        return ()+     ) (do+        return ()+     )++-- method Credentials::to_string+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Credentials", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Credentials", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_credentials_to_string" g_credentials_to_string :: +    Ptr Credentials ->                      -- _obj : TInterface "Gio" "Credentials"+    IO CString+++credentialsToString ::+    (MonadIO m, CredentialsK a) =>+    a ->                                    -- _obj+    m T.Text+credentialsToString _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_credentials_to_string _obj'+    checkUnexpectedReturnNULL "g_credentials_to_string" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++
+ GI/Gio/Objects/Credentials.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Objects.Credentials where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Credentials = Credentials (ForeignPtr Credentials)+instance GObject Credentials where+class GObject o => CredentialsK o+instance (GObject o, IsDescendantOf Credentials o) => CredentialsK o
+ GI/Gio/Objects/DBusActionGroup.hs view
@@ -0,0 +1,99 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.DBusActionGroup+    ( ++-- * Exported types+    DBusActionGroup(..)                     ,+    DBusActionGroupK                        ,+    toDBusActionGroup                       ,+    noDBusActionGroup                       ,+++ -- * Methods+-- ** dBusActionGroupGet+    dBusActionGroupGet                      ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype DBusActionGroup = DBusActionGroup (ForeignPtr DBusActionGroup)+foreign import ccall "g_dbus_action_group_get_type"+    c_g_dbus_action_group_get_type :: IO GType++type instance ParentTypes DBusActionGroup = DBusActionGroupParentTypes+type DBusActionGroupParentTypes = '[GObject.Object, ActionGroup, RemoteActionGroup]++instance GObject DBusActionGroup where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_dbus_action_group_get_type+    ++class GObject o => DBusActionGroupK o+instance (GObject o, IsDescendantOf DBusActionGroup o) => DBusActionGroupK o++toDBusActionGroup :: DBusActionGroupK o => o -> IO DBusActionGroup+toDBusActionGroup = unsafeCastTo DBusActionGroup++noDBusActionGroup :: Maybe DBusActionGroup+noDBusActionGroup = Nothing++type instance AttributeList DBusActionGroup = DBusActionGroupAttributeList+type DBusActionGroupAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList DBusActionGroup = DBusActionGroupSignalList+type DBusActionGroupSignalList = ('[ '("action-added", ActionGroupActionAddedSignalInfo), '("action-enabled-changed", ActionGroupActionEnabledChangedSignalInfo), '("action-removed", ActionGroupActionRemovedSignalInfo), '("action-state-changed", ActionGroupActionStateChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method DBusActionGroup::get+-- method type : MemberFunction+-- Args : [Arg {argName = "connection", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "bus_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "connection", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "bus_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusActionGroup"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_action_group_get" g_dbus_action_group_get :: +    Ptr DBusConnection ->                   -- connection : TInterface "Gio" "DBusConnection"+    CString ->                              -- bus_name : TBasicType TUTF8+    CString ->                              -- object_path : TBasicType TUTF8+    IO (Ptr DBusActionGroup)+++dBusActionGroupGet ::+    (MonadIO m, DBusConnectionK a) =>+    a ->                                    -- connection+    T.Text ->                               -- bus_name+    T.Text ->                               -- object_path+    m DBusActionGroup+dBusActionGroupGet connection bus_name object_path = liftIO $ do+    let connection' = unsafeManagedPtrCastPtr connection+    bus_name' <- textToCString bus_name+    object_path' <- textToCString object_path+    result <- g_dbus_action_group_get connection' bus_name' object_path'+    checkUnexpectedReturnNULL "g_dbus_action_group_get" result+    result' <- (wrapObject DBusActionGroup) result+    touchManagedPtr connection+    freeMem bus_name'+    freeMem object_path'+    return result'++
+ GI/Gio/Objects/DBusActionGroup.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Objects.DBusActionGroup where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype DBusActionGroup = DBusActionGroup (ForeignPtr DBusActionGroup)+instance GObject DBusActionGroup where+class GObject o => DBusActionGroupK o+instance (GObject o, IsDescendantOf DBusActionGroup o) => DBusActionGroupK o
+ GI/Gio/Objects/DBusAuthObserver.hs view
@@ -0,0 +1,295 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.DBusAuthObserver+    ( ++-- * Exported types+    DBusAuthObserver(..)                    ,+    DBusAuthObserverK                       ,+    toDBusAuthObserver                      ,+    noDBusAuthObserver                      ,+++ -- * Methods+-- ** dBusAuthObserverAllowMechanism+    dBusAuthObserverAllowMechanism          ,+++-- ** dBusAuthObserverAuthorizeAuthenticatedPeer+    dBusAuthObserverAuthorizeAuthenticatedPeer,+++-- ** dBusAuthObserverNew+    dBusAuthObserverNew                     ,+++++ -- * Signals+-- ** AllowMechanism+    DBusAuthObserverAllowMechanismCallback  ,+    DBusAuthObserverAllowMechanismCallbackC ,+    DBusAuthObserverAllowMechanismSignalInfo,+    afterDBusAuthObserverAllowMechanism     ,+    dBusAuthObserverAllowMechanismCallbackWrapper,+    dBusAuthObserverAllowMechanismClosure   ,+    mkDBusAuthObserverAllowMechanismCallback,+    noDBusAuthObserverAllowMechanismCallback,+    onDBusAuthObserverAllowMechanism        ,+++-- ** AuthorizeAuthenticatedPeer+    DBusAuthObserverAuthorizeAuthenticatedPeerCallback,+    DBusAuthObserverAuthorizeAuthenticatedPeerCallbackC,+    DBusAuthObserverAuthorizeAuthenticatedPeerSignalInfo,+    afterDBusAuthObserverAuthorizeAuthenticatedPeer,+    dBusAuthObserverAuthorizeAuthenticatedPeerCallbackWrapper,+    dBusAuthObserverAuthorizeAuthenticatedPeerClosure,+    mkDBusAuthObserverAuthorizeAuthenticatedPeerCallback,+    noDBusAuthObserverAuthorizeAuthenticatedPeerCallback,+    onDBusAuthObserverAuthorizeAuthenticatedPeer,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype DBusAuthObserver = DBusAuthObserver (ForeignPtr DBusAuthObserver)+foreign import ccall "g_dbus_auth_observer_get_type"+    c_g_dbus_auth_observer_get_type :: IO GType++type instance ParentTypes DBusAuthObserver = DBusAuthObserverParentTypes+type DBusAuthObserverParentTypes = '[GObject.Object]++instance GObject DBusAuthObserver where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_dbus_auth_observer_get_type+    ++class GObject o => DBusAuthObserverK o+instance (GObject o, IsDescendantOf DBusAuthObserver o) => DBusAuthObserverK o++toDBusAuthObserver :: DBusAuthObserverK o => o -> IO DBusAuthObserver+toDBusAuthObserver = unsafeCastTo DBusAuthObserver++noDBusAuthObserver :: Maybe DBusAuthObserver+noDBusAuthObserver = Nothing++-- signal DBusAuthObserver::allow-mechanism+type DBusAuthObserverAllowMechanismCallback =+    T.Text ->+    IO Bool++noDBusAuthObserverAllowMechanismCallback :: Maybe DBusAuthObserverAllowMechanismCallback+noDBusAuthObserverAllowMechanismCallback = Nothing++type DBusAuthObserverAllowMechanismCallbackC =+    Ptr () ->                               -- object+    CString ->+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkDBusAuthObserverAllowMechanismCallback :: DBusAuthObserverAllowMechanismCallbackC -> IO (FunPtr DBusAuthObserverAllowMechanismCallbackC)++dBusAuthObserverAllowMechanismClosure :: DBusAuthObserverAllowMechanismCallback -> IO Closure+dBusAuthObserverAllowMechanismClosure cb = newCClosure =<< mkDBusAuthObserverAllowMechanismCallback wrapped+    where wrapped = dBusAuthObserverAllowMechanismCallbackWrapper cb++dBusAuthObserverAllowMechanismCallbackWrapper ::+    DBusAuthObserverAllowMechanismCallback ->+    Ptr () ->+    CString ->+    Ptr () ->+    IO CInt+dBusAuthObserverAllowMechanismCallbackWrapper _cb _ mechanism _ = do+    mechanism' <- cstringToText mechanism+    result <- _cb  mechanism'+    let result' = (fromIntegral . fromEnum) result+    return result'++onDBusAuthObserverAllowMechanism :: (GObject a, MonadIO m) => a -> DBusAuthObserverAllowMechanismCallback -> m SignalHandlerId+onDBusAuthObserverAllowMechanism obj cb = liftIO $ connectDBusAuthObserverAllowMechanism obj cb SignalConnectBefore+afterDBusAuthObserverAllowMechanism :: (GObject a, MonadIO m) => a -> DBusAuthObserverAllowMechanismCallback -> m SignalHandlerId+afterDBusAuthObserverAllowMechanism obj cb = connectDBusAuthObserverAllowMechanism obj cb SignalConnectAfter++connectDBusAuthObserverAllowMechanism :: (GObject a, MonadIO m) =>+                                         a -> DBusAuthObserverAllowMechanismCallback -> SignalConnectMode -> m SignalHandlerId+connectDBusAuthObserverAllowMechanism obj cb after = liftIO $ do+    cb' <- mkDBusAuthObserverAllowMechanismCallback (dBusAuthObserverAllowMechanismCallbackWrapper cb)+    connectSignalFunPtr obj "allow-mechanism" cb' after++-- signal DBusAuthObserver::authorize-authenticated-peer+type DBusAuthObserverAuthorizeAuthenticatedPeerCallback =+    IOStream ->+    Maybe Credentials ->+    IO Bool++noDBusAuthObserverAuthorizeAuthenticatedPeerCallback :: Maybe DBusAuthObserverAuthorizeAuthenticatedPeerCallback+noDBusAuthObserverAuthorizeAuthenticatedPeerCallback = Nothing++type DBusAuthObserverAuthorizeAuthenticatedPeerCallbackC =+    Ptr () ->                               -- object+    Ptr IOStream ->+    Ptr Credentials ->+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkDBusAuthObserverAuthorizeAuthenticatedPeerCallback :: DBusAuthObserverAuthorizeAuthenticatedPeerCallbackC -> IO (FunPtr DBusAuthObserverAuthorizeAuthenticatedPeerCallbackC)++dBusAuthObserverAuthorizeAuthenticatedPeerClosure :: DBusAuthObserverAuthorizeAuthenticatedPeerCallback -> IO Closure+dBusAuthObserverAuthorizeAuthenticatedPeerClosure cb = newCClosure =<< mkDBusAuthObserverAuthorizeAuthenticatedPeerCallback wrapped+    where wrapped = dBusAuthObserverAuthorizeAuthenticatedPeerCallbackWrapper cb++dBusAuthObserverAuthorizeAuthenticatedPeerCallbackWrapper ::+    DBusAuthObserverAuthorizeAuthenticatedPeerCallback ->+    Ptr () ->+    Ptr IOStream ->+    Ptr Credentials ->+    Ptr () ->+    IO CInt+dBusAuthObserverAuthorizeAuthenticatedPeerCallbackWrapper _cb _ stream credentials _ = do+    stream' <- (newObject IOStream) stream+    maybeCredentials <-+        if credentials == nullPtr+        then return Nothing+        else do+            credentials' <- (newObject Credentials) credentials+            return $ Just credentials'+    result <- _cb  stream' maybeCredentials+    let result' = (fromIntegral . fromEnum) result+    return result'++onDBusAuthObserverAuthorizeAuthenticatedPeer :: (GObject a, MonadIO m) => a -> DBusAuthObserverAuthorizeAuthenticatedPeerCallback -> m SignalHandlerId+onDBusAuthObserverAuthorizeAuthenticatedPeer obj cb = liftIO $ connectDBusAuthObserverAuthorizeAuthenticatedPeer obj cb SignalConnectBefore+afterDBusAuthObserverAuthorizeAuthenticatedPeer :: (GObject a, MonadIO m) => a -> DBusAuthObserverAuthorizeAuthenticatedPeerCallback -> m SignalHandlerId+afterDBusAuthObserverAuthorizeAuthenticatedPeer obj cb = connectDBusAuthObserverAuthorizeAuthenticatedPeer obj cb SignalConnectAfter++connectDBusAuthObserverAuthorizeAuthenticatedPeer :: (GObject a, MonadIO m) =>+                                                     a -> DBusAuthObserverAuthorizeAuthenticatedPeerCallback -> SignalConnectMode -> m SignalHandlerId+connectDBusAuthObserverAuthorizeAuthenticatedPeer obj cb after = liftIO $ do+    cb' <- mkDBusAuthObserverAuthorizeAuthenticatedPeerCallback (dBusAuthObserverAuthorizeAuthenticatedPeerCallbackWrapper cb)+    connectSignalFunPtr obj "authorize-authenticated-peer" cb' after++type instance AttributeList DBusAuthObserver = DBusAuthObserverAttributeList+type DBusAuthObserverAttributeList = ('[ ] :: [(Symbol, *)])++data DBusAuthObserverAllowMechanismSignalInfo+instance SignalInfo DBusAuthObserverAllowMechanismSignalInfo where+    type HaskellCallbackType DBusAuthObserverAllowMechanismSignalInfo = DBusAuthObserverAllowMechanismCallback+    connectSignal _ = connectDBusAuthObserverAllowMechanism++data DBusAuthObserverAuthorizeAuthenticatedPeerSignalInfo+instance SignalInfo DBusAuthObserverAuthorizeAuthenticatedPeerSignalInfo where+    type HaskellCallbackType DBusAuthObserverAuthorizeAuthenticatedPeerSignalInfo = DBusAuthObserverAuthorizeAuthenticatedPeerCallback+    connectSignal _ = connectDBusAuthObserverAuthorizeAuthenticatedPeer++type instance SignalList DBusAuthObserver = DBusAuthObserverSignalList+type DBusAuthObserverSignalList = ('[ '("allow-mechanism", DBusAuthObserverAllowMechanismSignalInfo), '("authorize-authenticated-peer", DBusAuthObserverAuthorizeAuthenticatedPeerSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method DBusAuthObserver::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gio" "DBusAuthObserver"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_auth_observer_new" g_dbus_auth_observer_new :: +    IO (Ptr DBusAuthObserver)+++dBusAuthObserverNew ::+    (MonadIO m) =>+    m DBusAuthObserver+dBusAuthObserverNew  = liftIO $ do+    result <- g_dbus_auth_observer_new+    checkUnexpectedReturnNULL "g_dbus_auth_observer_new" result+    result' <- (wrapObject DBusAuthObserver) result+    return result'++-- method DBusAuthObserver::allow_mechanism+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusAuthObserver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mechanism", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusAuthObserver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mechanism", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_auth_observer_allow_mechanism" g_dbus_auth_observer_allow_mechanism :: +    Ptr DBusAuthObserver ->                 -- _obj : TInterface "Gio" "DBusAuthObserver"+    CString ->                              -- mechanism : TBasicType TUTF8+    IO CInt+++dBusAuthObserverAllowMechanism ::+    (MonadIO m, DBusAuthObserverK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- mechanism+    m Bool+dBusAuthObserverAllowMechanism _obj mechanism = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    mechanism' <- textToCString mechanism+    result <- g_dbus_auth_observer_allow_mechanism _obj' mechanism'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem mechanism'+    return result'++-- method DBusAuthObserver::authorize_authenticated_peer+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusAuthObserver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stream", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "credentials", argType = TInterface "Gio" "Credentials", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusAuthObserver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stream", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "credentials", argType = TInterface "Gio" "Credentials", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_auth_observer_authorize_authenticated_peer" g_dbus_auth_observer_authorize_authenticated_peer :: +    Ptr DBusAuthObserver ->                 -- _obj : TInterface "Gio" "DBusAuthObserver"+    Ptr IOStream ->                         -- stream : TInterface "Gio" "IOStream"+    Ptr Credentials ->                      -- credentials : TInterface "Gio" "Credentials"+    IO CInt+++dBusAuthObserverAuthorizeAuthenticatedPeer ::+    (MonadIO m, DBusAuthObserverK a, IOStreamK b, CredentialsK c) =>+    a ->                                    -- _obj+    b ->                                    -- stream+    Maybe (c) ->                            -- credentials+    m Bool+dBusAuthObserverAuthorizeAuthenticatedPeer _obj stream credentials = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let stream' = unsafeManagedPtrCastPtr stream+    maybeCredentials <- case credentials of+        Nothing -> return nullPtr+        Just jCredentials -> do+            let jCredentials' = unsafeManagedPtrCastPtr jCredentials+            return jCredentials'+    result <- g_dbus_auth_observer_authorize_authenticated_peer _obj' stream' maybeCredentials+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr stream+    whenJust credentials touchManagedPtr+    return result'++
+ GI/Gio/Objects/DBusAuthObserver.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gio.Objects.DBusAuthObserver where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype DBusAuthObserver = DBusAuthObserver (ForeignPtr DBusAuthObserver)+instance GObject DBusAuthObserver where+class GObject o => DBusAuthObserverK o+instance (GObject o, IsDescendantOf DBusAuthObserver o) => DBusAuthObserverK o+data DBusAuthObserverAllowMechanismSignalInfo+data DBusAuthObserverAuthorizeAuthenticatedPeerSignalInfo
+ GI/Gio/Objects/DBusConnection.hs view
@@ -0,0 +1,2419 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.DBusConnection+    ( ++-- * Exported types+    DBusConnection(..)                      ,+    DBusConnectionK                         ,+    toDBusConnection                        ,+    noDBusConnection                        ,+++ -- * Methods+-- ** dBusConnectionAddFilter+    dBusConnectionAddFilter                 ,+++-- ** dBusConnectionCall+    dBusConnectionCall                      ,+++-- ** dBusConnectionCallFinish+    dBusConnectionCallFinish                ,+++-- ** dBusConnectionCallSync+    dBusConnectionCallSync                  ,+++-- ** dBusConnectionCallWithUnixFdList+    dBusConnectionCallWithUnixFdList        ,+++-- ** dBusConnectionCallWithUnixFdListFinish+    dBusConnectionCallWithUnixFdListFinish  ,+++-- ** dBusConnectionCallWithUnixFdListSync+    dBusConnectionCallWithUnixFdListSync    ,+++-- ** dBusConnectionClose+    dBusConnectionClose                     ,+++-- ** dBusConnectionCloseFinish+    dBusConnectionCloseFinish               ,+++-- ** dBusConnectionCloseSync+    dBusConnectionCloseSync                 ,+++-- ** dBusConnectionEmitSignal+    dBusConnectionEmitSignal                ,+++-- ** dBusConnectionExportActionGroup+    dBusConnectionExportActionGroup         ,+++-- ** dBusConnectionExportMenuModel+    dBusConnectionExportMenuModel           ,+++-- ** dBusConnectionFlush+    dBusConnectionFlush                     ,+++-- ** dBusConnectionFlushFinish+    dBusConnectionFlushFinish               ,+++-- ** dBusConnectionFlushSync+    dBusConnectionFlushSync                 ,+++-- ** dBusConnectionGetCapabilities+    dBusConnectionGetCapabilities           ,+++-- ** dBusConnectionGetExitOnClose+    dBusConnectionGetExitOnClose            ,+++-- ** dBusConnectionGetGuid+    dBusConnectionGetGuid                   ,+++-- ** dBusConnectionGetLastSerial+    dBusConnectionGetLastSerial             ,+++-- ** dBusConnectionGetPeerCredentials+    dBusConnectionGetPeerCredentials        ,+++-- ** dBusConnectionGetStream+    dBusConnectionGetStream                 ,+++-- ** dBusConnectionGetUniqueName+    dBusConnectionGetUniqueName             ,+++-- ** dBusConnectionIsClosed+    dBusConnectionIsClosed                  ,+++-- ** dBusConnectionNew+    dBusConnectionNew                       ,+++-- ** dBusConnectionNewFinish+    dBusConnectionNewFinish                 ,+++-- ** dBusConnectionNewForAddress+    dBusConnectionNewForAddress             ,+++-- ** dBusConnectionNewForAddressFinish+    dBusConnectionNewForAddressFinish       ,+++-- ** dBusConnectionNewForAddressSync+    dBusConnectionNewForAddressSync         ,+++-- ** dBusConnectionNewSync+    dBusConnectionNewSync                   ,+++-- ** dBusConnectionRegisterObject+    dBusConnectionRegisterObject            ,+++-- ** dBusConnectionRegisterSubtree+    dBusConnectionRegisterSubtree           ,+++-- ** dBusConnectionRemoveFilter+    dBusConnectionRemoveFilter              ,+++-- ** dBusConnectionSendMessage+    dBusConnectionSendMessage               ,+++-- ** dBusConnectionSendMessageWithReply+    dBusConnectionSendMessageWithReply      ,+++-- ** dBusConnectionSendMessageWithReplyFinish+    dBusConnectionSendMessageWithReplyFinish,+++-- ** dBusConnectionSendMessageWithReplySync+    dBusConnectionSendMessageWithReplySync  ,+++-- ** dBusConnectionSetExitOnClose+    dBusConnectionSetExitOnClose            ,+++-- ** dBusConnectionSignalSubscribe+    dBusConnectionSignalSubscribe           ,+++-- ** dBusConnectionSignalUnsubscribe+    dBusConnectionSignalUnsubscribe         ,+++-- ** dBusConnectionStartMessageProcessing+    dBusConnectionStartMessageProcessing    ,+++-- ** dBusConnectionUnexportActionGroup+    dBusConnectionUnexportActionGroup       ,+++-- ** dBusConnectionUnexportMenuModel+    dBusConnectionUnexportMenuModel         ,+++-- ** dBusConnectionUnregisterObject+    dBusConnectionUnregisterObject          ,+++-- ** dBusConnectionUnregisterSubtree+    dBusConnectionUnregisterSubtree         ,+++++ -- * Properties+-- ** Address+    DBusConnectionAddressPropertyInfo       ,+    constructDBusConnectionAddress          ,+++-- ** AuthenticationObserver+    DBusConnectionAuthenticationObserverPropertyInfo,+    constructDBusConnectionAuthenticationObserver,+++-- ** Capabilities+    DBusConnectionCapabilitiesPropertyInfo  ,+    getDBusConnectionCapabilities           ,+++-- ** Closed+    DBusConnectionClosedPropertyInfo        ,+    getDBusConnectionClosed                 ,+++-- ** ExitOnClose+    DBusConnectionExitOnClosePropertyInfo   ,+    constructDBusConnectionExitOnClose      ,+    getDBusConnectionExitOnClose            ,+    setDBusConnectionExitOnClose            ,+++-- ** Flags+    DBusConnectionFlagsPropertyInfo         ,+    constructDBusConnectionFlags            ,+++-- ** Guid+    DBusConnectionGuidPropertyInfo          ,+    constructDBusConnectionGuid             ,+    getDBusConnectionGuid                   ,+++-- ** Stream+    DBusConnectionStreamPropertyInfo        ,+    constructDBusConnectionStream           ,+    getDBusConnectionStream                 ,+++-- ** UniqueName+    DBusConnectionUniqueNamePropertyInfo    ,+    getDBusConnectionUniqueName             ,+++++ -- * Signals+-- ** Closed+    DBusConnectionClosedCallback            ,+    DBusConnectionClosedCallbackC           ,+    DBusConnectionClosedSignalInfo          ,+    afterDBusConnectionClosed               ,+    dBusConnectionClosedCallbackWrapper     ,+    dBusConnectionClosedClosure             ,+    mkDBusConnectionClosedCallback          ,+    noDBusConnectionClosedCallback          ,+    onDBusConnectionClosed                  ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype DBusConnection = DBusConnection (ForeignPtr DBusConnection)+foreign import ccall "g_dbus_connection_get_type"+    c_g_dbus_connection_get_type :: IO GType++type instance ParentTypes DBusConnection = DBusConnectionParentTypes+type DBusConnectionParentTypes = '[GObject.Object, AsyncInitable, Initable]++instance GObject DBusConnection where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_dbus_connection_get_type+    ++class GObject o => DBusConnectionK o+instance (GObject o, IsDescendantOf DBusConnection o) => DBusConnectionK o++toDBusConnection :: DBusConnectionK o => o -> IO DBusConnection+toDBusConnection = unsafeCastTo DBusConnection++noDBusConnection :: Maybe DBusConnection+noDBusConnection = Nothing++-- signal DBusConnection::closed+type DBusConnectionClosedCallback =+    Bool ->+    Maybe GError ->+    IO ()++noDBusConnectionClosedCallback :: Maybe DBusConnectionClosedCallback+noDBusConnectionClosedCallback = Nothing++type DBusConnectionClosedCallbackC =+    Ptr () ->                               -- object+    CInt ->+    Ptr GError ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkDBusConnectionClosedCallback :: DBusConnectionClosedCallbackC -> IO (FunPtr DBusConnectionClosedCallbackC)++dBusConnectionClosedClosure :: DBusConnectionClosedCallback -> IO Closure+dBusConnectionClosedClosure cb = newCClosure =<< mkDBusConnectionClosedCallback wrapped+    where wrapped = dBusConnectionClosedCallbackWrapper cb++dBusConnectionClosedCallbackWrapper ::+    DBusConnectionClosedCallback ->+    Ptr () ->+    CInt ->+    Ptr GError ->+    Ptr () ->+    IO ()+dBusConnectionClosedCallbackWrapper _cb _ remote_peer_vanished error_ _ = do+    let remote_peer_vanished' = (/= 0) remote_peer_vanished+    maybeError_ <-+        if error_ == nullPtr+        then return Nothing+        else do+            error_' <- (newBoxed GError) error_+            return $ Just error_'+    _cb  remote_peer_vanished' maybeError_++onDBusConnectionClosed :: (GObject a, MonadIO m) => a -> DBusConnectionClosedCallback -> m SignalHandlerId+onDBusConnectionClosed obj cb = liftIO $ connectDBusConnectionClosed obj cb SignalConnectBefore+afterDBusConnectionClosed :: (GObject a, MonadIO m) => a -> DBusConnectionClosedCallback -> m SignalHandlerId+afterDBusConnectionClosed obj cb = connectDBusConnectionClosed obj cb SignalConnectAfter++connectDBusConnectionClosed :: (GObject a, MonadIO m) =>+                               a -> DBusConnectionClosedCallback -> SignalConnectMode -> m SignalHandlerId+connectDBusConnectionClosed obj cb after = liftIO $ do+    cb' <- mkDBusConnectionClosedCallback (dBusConnectionClosedCallbackWrapper cb)+    connectSignalFunPtr obj "closed" cb' after++-- VVV Prop "address"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyWritable,PropertyConstructOnly]++constructDBusConnectionAddress :: T.Text -> IO ([Char], GValue)+constructDBusConnectionAddress val = constructObjectPropertyString "address" val++data DBusConnectionAddressPropertyInfo+instance AttrInfo DBusConnectionAddressPropertyInfo where+    type AttrAllowedOps DBusConnectionAddressPropertyInfo = '[ 'AttrConstruct]+    type AttrSetTypeConstraint DBusConnectionAddressPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint DBusConnectionAddressPropertyInfo = DBusConnectionK+    type AttrGetType DBusConnectionAddressPropertyInfo = ()+    type AttrLabel DBusConnectionAddressPropertyInfo = "DBusConnection::address"+    attrGet _ = undefined+    attrSet _ = undefined+    attrConstruct _ = constructDBusConnectionAddress++-- VVV Prop "authentication-observer"+   -- Type: TInterface "Gio" "DBusAuthObserver"+   -- Flags: [PropertyWritable,PropertyConstructOnly]++constructDBusConnectionAuthenticationObserver :: (DBusAuthObserverK a) => a -> IO ([Char], GValue)+constructDBusConnectionAuthenticationObserver val = constructObjectPropertyObject "authentication-observer" val++data DBusConnectionAuthenticationObserverPropertyInfo+instance AttrInfo DBusConnectionAuthenticationObserverPropertyInfo where+    type AttrAllowedOps DBusConnectionAuthenticationObserverPropertyInfo = '[ 'AttrConstruct]+    type AttrSetTypeConstraint DBusConnectionAuthenticationObserverPropertyInfo = DBusAuthObserverK+    type AttrBaseTypeConstraint DBusConnectionAuthenticationObserverPropertyInfo = DBusConnectionK+    type AttrGetType DBusConnectionAuthenticationObserverPropertyInfo = ()+    type AttrLabel DBusConnectionAuthenticationObserverPropertyInfo = "DBusConnection::authentication-observer"+    attrGet _ = undefined+    attrSet _ = undefined+    attrConstruct _ = constructDBusConnectionAuthenticationObserver++-- VVV Prop "capabilities"+   -- Type: TInterface "Gio" "DBusCapabilityFlags"+   -- Flags: [PropertyReadable]++getDBusConnectionCapabilities :: (MonadIO m, DBusConnectionK o) => o -> m [DBusCapabilityFlags]+getDBusConnectionCapabilities obj = liftIO $ getObjectPropertyFlags obj "capabilities"++data DBusConnectionCapabilitiesPropertyInfo+instance AttrInfo DBusConnectionCapabilitiesPropertyInfo where+    type AttrAllowedOps DBusConnectionCapabilitiesPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint DBusConnectionCapabilitiesPropertyInfo = (~) ()+    type AttrBaseTypeConstraint DBusConnectionCapabilitiesPropertyInfo = DBusConnectionK+    type AttrGetType DBusConnectionCapabilitiesPropertyInfo = [DBusCapabilityFlags]+    type AttrLabel DBusConnectionCapabilitiesPropertyInfo = "DBusConnection::capabilities"+    attrGet _ = getDBusConnectionCapabilities+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "closed"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getDBusConnectionClosed :: (MonadIO m, DBusConnectionK o) => o -> m Bool+getDBusConnectionClosed obj = liftIO $ getObjectPropertyBool obj "closed"++data DBusConnectionClosedPropertyInfo+instance AttrInfo DBusConnectionClosedPropertyInfo where+    type AttrAllowedOps DBusConnectionClosedPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint DBusConnectionClosedPropertyInfo = (~) ()+    type AttrBaseTypeConstraint DBusConnectionClosedPropertyInfo = DBusConnectionK+    type AttrGetType DBusConnectionClosedPropertyInfo = Bool+    type AttrLabel DBusConnectionClosedPropertyInfo = "DBusConnection::closed"+    attrGet _ = getDBusConnectionClosed+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "exit-on-close"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getDBusConnectionExitOnClose :: (MonadIO m, DBusConnectionK o) => o -> m Bool+getDBusConnectionExitOnClose obj = liftIO $ getObjectPropertyBool obj "exit-on-close"++setDBusConnectionExitOnClose :: (MonadIO m, DBusConnectionK o) => o -> Bool -> m ()+setDBusConnectionExitOnClose obj val = liftIO $ setObjectPropertyBool obj "exit-on-close" val++constructDBusConnectionExitOnClose :: Bool -> IO ([Char], GValue)+constructDBusConnectionExitOnClose val = constructObjectPropertyBool "exit-on-close" val++data DBusConnectionExitOnClosePropertyInfo+instance AttrInfo DBusConnectionExitOnClosePropertyInfo where+    type AttrAllowedOps DBusConnectionExitOnClosePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DBusConnectionExitOnClosePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint DBusConnectionExitOnClosePropertyInfo = DBusConnectionK+    type AttrGetType DBusConnectionExitOnClosePropertyInfo = Bool+    type AttrLabel DBusConnectionExitOnClosePropertyInfo = "DBusConnection::exit-on-close"+    attrGet _ = getDBusConnectionExitOnClose+    attrSet _ = setDBusConnectionExitOnClose+    attrConstruct _ = constructDBusConnectionExitOnClose++-- VVV Prop "flags"+   -- Type: TInterface "Gio" "DBusConnectionFlags"+   -- Flags: [PropertyWritable,PropertyConstructOnly]++constructDBusConnectionFlags :: [DBusConnectionFlags] -> IO ([Char], GValue)+constructDBusConnectionFlags val = constructObjectPropertyFlags "flags" val++data DBusConnectionFlagsPropertyInfo+instance AttrInfo DBusConnectionFlagsPropertyInfo where+    type AttrAllowedOps DBusConnectionFlagsPropertyInfo = '[ 'AttrConstruct]+    type AttrSetTypeConstraint DBusConnectionFlagsPropertyInfo = (~) [DBusConnectionFlags]+    type AttrBaseTypeConstraint DBusConnectionFlagsPropertyInfo = DBusConnectionK+    type AttrGetType DBusConnectionFlagsPropertyInfo = ()+    type AttrLabel DBusConnectionFlagsPropertyInfo = "DBusConnection::flags"+    attrGet _ = undefined+    attrSet _ = undefined+    attrConstruct _ = constructDBusConnectionFlags++-- VVV Prop "guid"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getDBusConnectionGuid :: (MonadIO m, DBusConnectionK o) => o -> m T.Text+getDBusConnectionGuid obj = liftIO $ getObjectPropertyString obj "guid"++constructDBusConnectionGuid :: T.Text -> IO ([Char], GValue)+constructDBusConnectionGuid val = constructObjectPropertyString "guid" val++data DBusConnectionGuidPropertyInfo+instance AttrInfo DBusConnectionGuidPropertyInfo where+    type AttrAllowedOps DBusConnectionGuidPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DBusConnectionGuidPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint DBusConnectionGuidPropertyInfo = DBusConnectionK+    type AttrGetType DBusConnectionGuidPropertyInfo = T.Text+    type AttrLabel DBusConnectionGuidPropertyInfo = "DBusConnection::guid"+    attrGet _ = getDBusConnectionGuid+    attrSet _ = undefined+    attrConstruct _ = constructDBusConnectionGuid++-- VVV Prop "stream"+   -- Type: TInterface "Gio" "IOStream"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getDBusConnectionStream :: (MonadIO m, DBusConnectionK o) => o -> m IOStream+getDBusConnectionStream obj = liftIO $ getObjectPropertyObject obj "stream" IOStream++constructDBusConnectionStream :: (IOStreamK a) => a -> IO ([Char], GValue)+constructDBusConnectionStream val = constructObjectPropertyObject "stream" val++data DBusConnectionStreamPropertyInfo+instance AttrInfo DBusConnectionStreamPropertyInfo where+    type AttrAllowedOps DBusConnectionStreamPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DBusConnectionStreamPropertyInfo = IOStreamK+    type AttrBaseTypeConstraint DBusConnectionStreamPropertyInfo = DBusConnectionK+    type AttrGetType DBusConnectionStreamPropertyInfo = IOStream+    type AttrLabel DBusConnectionStreamPropertyInfo = "DBusConnection::stream"+    attrGet _ = getDBusConnectionStream+    attrSet _ = undefined+    attrConstruct _ = constructDBusConnectionStream++-- VVV Prop "unique-name"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable]++getDBusConnectionUniqueName :: (MonadIO m, DBusConnectionK o) => o -> m T.Text+getDBusConnectionUniqueName obj = liftIO $ getObjectPropertyString obj "unique-name"++data DBusConnectionUniqueNamePropertyInfo+instance AttrInfo DBusConnectionUniqueNamePropertyInfo where+    type AttrAllowedOps DBusConnectionUniqueNamePropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint DBusConnectionUniqueNamePropertyInfo = (~) ()+    type AttrBaseTypeConstraint DBusConnectionUniqueNamePropertyInfo = DBusConnectionK+    type AttrGetType DBusConnectionUniqueNamePropertyInfo = T.Text+    type AttrLabel DBusConnectionUniqueNamePropertyInfo = "DBusConnection::unique-name"+    attrGet _ = getDBusConnectionUniqueName+    attrSet _ = undefined+    attrConstruct _ = undefined++type instance AttributeList DBusConnection = DBusConnectionAttributeList+type DBusConnectionAttributeList = ('[ '("address", DBusConnectionAddressPropertyInfo), '("authentication-observer", DBusConnectionAuthenticationObserverPropertyInfo), '("capabilities", DBusConnectionCapabilitiesPropertyInfo), '("closed", DBusConnectionClosedPropertyInfo), '("exit-on-close", DBusConnectionExitOnClosePropertyInfo), '("flags", DBusConnectionFlagsPropertyInfo), '("guid", DBusConnectionGuidPropertyInfo), '("stream", DBusConnectionStreamPropertyInfo), '("unique-name", DBusConnectionUniqueNamePropertyInfo)] :: [(Symbol, *)])++data DBusConnectionClosedSignalInfo+instance SignalInfo DBusConnectionClosedSignalInfo where+    type HaskellCallbackType DBusConnectionClosedSignalInfo = DBusConnectionClosedCallback+    connectSignal _ = connectDBusConnectionClosed++type instance SignalList DBusConnection = DBusConnectionSignalList+type DBusConnectionSignalList = ('[ '("closed", DBusConnectionClosedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method DBusConnection::new_finish+-- method type : Constructor+-- Args : [Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusConnection"+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_connection_new_finish" g_dbus_connection_new_finish :: +    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr DBusConnection)+++dBusConnectionNewFinish ::+    (MonadIO m, AsyncResultK a) =>+    a ->                                    -- res+    m DBusConnection+dBusConnectionNewFinish res = liftIO $ do+    let res' = unsafeManagedPtrCastPtr res+    onException (do+        result <- propagateGError $ g_dbus_connection_new_finish res'+        checkUnexpectedReturnNULL "g_dbus_connection_new_finish" result+        result' <- (wrapObject DBusConnection) result+        touchManagedPtr res+        return result'+     ) (do+        return ()+     )++-- method DBusConnection::new_for_address_finish+-- method type : Constructor+-- Args : [Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusConnection"+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_connection_new_for_address_finish" g_dbus_connection_new_for_address_finish :: +    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr DBusConnection)+++dBusConnectionNewForAddressFinish ::+    (MonadIO m, AsyncResultK a) =>+    a ->                                    -- res+    m DBusConnection+dBusConnectionNewForAddressFinish res = liftIO $ do+    let res' = unsafeManagedPtrCastPtr res+    onException (do+        result <- propagateGError $ g_dbus_connection_new_for_address_finish res'+        checkUnexpectedReturnNULL "g_dbus_connection_new_for_address_finish" result+        result' <- (wrapObject DBusConnection) result+        touchManagedPtr res+        return result'+     ) (do+        return ()+     )++-- method DBusConnection::new_for_address_sync+-- method type : Constructor+-- Args : [Arg {argName = "address", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusConnectionFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "observer", argType = TInterface "Gio" "DBusAuthObserver", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "address", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusConnectionFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "observer", argType = TInterface "Gio" "DBusAuthObserver", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusConnection"+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_connection_new_for_address_sync" g_dbus_connection_new_for_address_sync :: +    CString ->                              -- address : TBasicType TUTF8+    CUInt ->                                -- flags : TInterface "Gio" "DBusConnectionFlags"+    Ptr DBusAuthObserver ->                 -- observer : TInterface "Gio" "DBusAuthObserver"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr DBusConnection)+++dBusConnectionNewForAddressSync ::+    (MonadIO m, DBusAuthObserverK a, CancellableK b) =>+    T.Text ->                               -- address+    [DBusConnectionFlags] ->                -- flags+    Maybe (a) ->                            -- observer+    Maybe (b) ->                            -- cancellable+    m DBusConnection+dBusConnectionNewForAddressSync address flags observer cancellable = liftIO $ do+    address' <- textToCString address+    let flags' = gflagsToWord flags+    maybeObserver <- case observer of+        Nothing -> return nullPtr+        Just jObserver -> do+            let jObserver' = unsafeManagedPtrCastPtr jObserver+            return jObserver'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_dbus_connection_new_for_address_sync address' flags' maybeObserver maybeCancellable+        checkUnexpectedReturnNULL "g_dbus_connection_new_for_address_sync" result+        result' <- (wrapObject DBusConnection) result+        whenJust observer touchManagedPtr+        whenJust cancellable touchManagedPtr+        freeMem address'+        return result'+     ) (do+        freeMem address'+     )++-- method DBusConnection::new_sync+-- method type : Constructor+-- Args : [Arg {argName = "stream", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "guid", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusConnectionFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "observer", argType = TInterface "Gio" "DBusAuthObserver", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "stream", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "guid", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusConnectionFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "observer", argType = TInterface "Gio" "DBusAuthObserver", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusConnection"+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_connection_new_sync" g_dbus_connection_new_sync :: +    Ptr IOStream ->                         -- stream : TInterface "Gio" "IOStream"+    CString ->                              -- guid : TBasicType TUTF8+    CUInt ->                                -- flags : TInterface "Gio" "DBusConnectionFlags"+    Ptr DBusAuthObserver ->                 -- observer : TInterface "Gio" "DBusAuthObserver"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr DBusConnection)+++dBusConnectionNewSync ::+    (MonadIO m, IOStreamK a, DBusAuthObserverK b, CancellableK c) =>+    a ->                                    -- stream+    Maybe (T.Text) ->                       -- guid+    [DBusConnectionFlags] ->                -- flags+    Maybe (b) ->                            -- observer+    Maybe (c) ->                            -- cancellable+    m DBusConnection+dBusConnectionNewSync stream guid flags observer cancellable = liftIO $ do+    let stream' = unsafeManagedPtrCastPtr stream+    maybeGuid <- case guid of+        Nothing -> return nullPtr+        Just jGuid -> do+            jGuid' <- textToCString jGuid+            return jGuid'+    let flags' = gflagsToWord flags+    maybeObserver <- case observer of+        Nothing -> return nullPtr+        Just jObserver -> do+            let jObserver' = unsafeManagedPtrCastPtr jObserver+            return jObserver'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_dbus_connection_new_sync stream' maybeGuid flags' maybeObserver maybeCancellable+        checkUnexpectedReturnNULL "g_dbus_connection_new_sync" result+        result' <- (wrapObject DBusConnection) result+        touchManagedPtr stream+        whenJust observer touchManagedPtr+        whenJust cancellable touchManagedPtr+        freeMem maybeGuid+        return result'+     ) (do+        freeMem maybeGuid+     )++-- method DBusConnection::add_filter+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filter_function", argType = TInterface "Gio" "DBusMessageFilterFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data_free_func", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filter_function", argType = TInterface "Gio" "DBusMessageFilterFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_connection_add_filter" g_dbus_connection_add_filter :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    FunPtr DBusMessageFilterFunctionC ->    -- filter_function : TInterface "Gio" "DBusMessageFilterFunction"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- user_data_free_func : TInterface "GLib" "DestroyNotify"+    IO Word32+++dBusConnectionAddFilter ::+    (MonadIO m, DBusConnectionK a) =>+    a ->                                    -- _obj+    DBusMessageFilterFunction ->            -- filter_function+    m Word32+dBusConnectionAddFilter _obj filter_function = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    filter_function' <- mkDBusMessageFilterFunction (dBusMessageFilterFunctionWrapper Nothing filter_function)+    let user_data = castFunPtrToPtr filter_function'+    let user_data_free_func = safeFreeFunPtrPtr+    result <- g_dbus_connection_add_filter _obj' filter_function' user_data user_data_free_func+    touchManagedPtr _obj+    return result++-- method DBusConnection::call+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "bus_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "method_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameters", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "reply_type", argType = TInterface "GLib" "VariantType", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusCallFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "timeout_msec", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 11, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "bus_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "method_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameters", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "reply_type", argType = TInterface "GLib" "VariantType", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusCallFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "timeout_msec", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 11, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_connection_call" g_dbus_connection_call :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    CString ->                              -- bus_name : TBasicType TUTF8+    CString ->                              -- object_path : TBasicType TUTF8+    CString ->                              -- interface_name : TBasicType TUTF8+    CString ->                              -- method_name : TBasicType TUTF8+    Ptr GVariant ->                         -- parameters : TVariant+    Ptr GLib.VariantType ->                 -- reply_type : TInterface "GLib" "VariantType"+    CUInt ->                                -- flags : TInterface "Gio" "DBusCallFlags"+    Int32 ->                                -- timeout_msec : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++dBusConnectionCall ::+    (MonadIO m, DBusConnectionK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- bus_name+    T.Text ->                               -- object_path+    T.Text ->                               -- interface_name+    T.Text ->                               -- method_name+    Maybe (GVariant) ->                     -- parameters+    Maybe (GLib.VariantType) ->             -- reply_type+    [DBusCallFlags] ->                      -- flags+    Int32 ->                                -- timeout_msec+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+dBusConnectionCall _obj bus_name object_path interface_name method_name parameters reply_type flags timeout_msec cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeBus_name <- case bus_name of+        Nothing -> return nullPtr+        Just jBus_name -> do+            jBus_name' <- textToCString jBus_name+            return jBus_name'+    object_path' <- textToCString object_path+    interface_name' <- textToCString interface_name+    method_name' <- textToCString method_name+    maybeParameters <- case parameters of+        Nothing -> return nullPtr+        Just jParameters -> do+            let jParameters' = unsafeManagedPtrGetPtr jParameters+            return jParameters'+    maybeReply_type <- case reply_type of+        Nothing -> return nullPtr+        Just jReply_type -> do+            let jReply_type' = unsafeManagedPtrGetPtr jReply_type+            return jReply_type'+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_dbus_connection_call _obj' maybeBus_name object_path' interface_name' method_name' maybeParameters maybeReply_type flags' timeout_msec maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust reply_type touchManagedPtr+    whenJust cancellable touchManagedPtr+    freeMem maybeBus_name+    freeMem object_path'+    freeMem interface_name'+    freeMem method_name'+    return ()++-- method DBusConnection::call_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TVariant+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_connection_call_finish" g_dbus_connection_call_finish :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr GVariant)+++dBusConnectionCallFinish ::+    (MonadIO m, DBusConnectionK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- res+    m GVariant+dBusConnectionCallFinish _obj res = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let res' = unsafeManagedPtrCastPtr res+    onException (do+        result <- propagateGError $ g_dbus_connection_call_finish _obj' res'+        checkUnexpectedReturnNULL "g_dbus_connection_call_finish" result+        result' <- wrapGVariantPtr result+        touchManagedPtr _obj+        touchManagedPtr res+        return result'+     ) (do+        return ()+     )++-- method DBusConnection::call_sync+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "bus_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "method_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameters", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "reply_type", argType = TInterface "GLib" "VariantType", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusCallFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "timeout_msec", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "bus_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "method_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameters", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "reply_type", argType = TInterface "GLib" "VariantType", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusCallFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "timeout_msec", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TVariant+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_connection_call_sync" g_dbus_connection_call_sync :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    CString ->                              -- bus_name : TBasicType TUTF8+    CString ->                              -- object_path : TBasicType TUTF8+    CString ->                              -- interface_name : TBasicType TUTF8+    CString ->                              -- method_name : TBasicType TUTF8+    Ptr GVariant ->                         -- parameters : TVariant+    Ptr GLib.VariantType ->                 -- reply_type : TInterface "GLib" "VariantType"+    CUInt ->                                -- flags : TInterface "Gio" "DBusCallFlags"+    Int32 ->                                -- timeout_msec : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr GVariant)+++dBusConnectionCallSync ::+    (MonadIO m, DBusConnectionK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- bus_name+    T.Text ->                               -- object_path+    T.Text ->                               -- interface_name+    T.Text ->                               -- method_name+    Maybe (GVariant) ->                     -- parameters+    Maybe (GLib.VariantType) ->             -- reply_type+    [DBusCallFlags] ->                      -- flags+    Int32 ->                                -- timeout_msec+    Maybe (b) ->                            -- cancellable+    m GVariant+dBusConnectionCallSync _obj bus_name object_path interface_name method_name parameters reply_type flags timeout_msec cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeBus_name <- case bus_name of+        Nothing -> return nullPtr+        Just jBus_name -> do+            jBus_name' <- textToCString jBus_name+            return jBus_name'+    object_path' <- textToCString object_path+    interface_name' <- textToCString interface_name+    method_name' <- textToCString method_name+    maybeParameters <- case parameters of+        Nothing -> return nullPtr+        Just jParameters -> do+            let jParameters' = unsafeManagedPtrGetPtr jParameters+            return jParameters'+    maybeReply_type <- case reply_type of+        Nothing -> return nullPtr+        Just jReply_type -> do+            let jReply_type' = unsafeManagedPtrGetPtr jReply_type+            return jReply_type'+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_dbus_connection_call_sync _obj' maybeBus_name object_path' interface_name' method_name' maybeParameters maybeReply_type flags' timeout_msec maybeCancellable+        checkUnexpectedReturnNULL "g_dbus_connection_call_sync" result+        result' <- wrapGVariantPtr result+        touchManagedPtr _obj+        whenJust reply_type touchManagedPtr+        whenJust cancellable touchManagedPtr+        freeMem maybeBus_name+        freeMem object_path'+        freeMem interface_name'+        freeMem method_name'+        return result'+     ) (do+        freeMem maybeBus_name+        freeMem object_path'+        freeMem interface_name'+        freeMem method_name'+     )++-- method DBusConnection::call_with_unix_fd_list+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "bus_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "method_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameters", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "reply_type", argType = TInterface "GLib" "VariantType", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusCallFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "timeout_msec", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fd_list", argType = TInterface "Gio" "UnixFDList", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 12, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "bus_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "method_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameters", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "reply_type", argType = TInterface "GLib" "VariantType", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusCallFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "timeout_msec", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fd_list", argType = TInterface "Gio" "UnixFDList", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 12, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_connection_call_with_unix_fd_list" g_dbus_connection_call_with_unix_fd_list :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    CString ->                              -- bus_name : TBasicType TUTF8+    CString ->                              -- object_path : TBasicType TUTF8+    CString ->                              -- interface_name : TBasicType TUTF8+    CString ->                              -- method_name : TBasicType TUTF8+    Ptr GVariant ->                         -- parameters : TVariant+    Ptr GLib.VariantType ->                 -- reply_type : TInterface "GLib" "VariantType"+    CUInt ->                                -- flags : TInterface "Gio" "DBusCallFlags"+    Int32 ->                                -- timeout_msec : TBasicType TInt32+    Ptr UnixFDList ->                       -- fd_list : TInterface "Gio" "UnixFDList"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++dBusConnectionCallWithUnixFdList ::+    (MonadIO m, DBusConnectionK a, UnixFDListK b, CancellableK c) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- bus_name+    T.Text ->                               -- object_path+    T.Text ->                               -- interface_name+    T.Text ->                               -- method_name+    Maybe (GVariant) ->                     -- parameters+    Maybe (GLib.VariantType) ->             -- reply_type+    [DBusCallFlags] ->                      -- flags+    Int32 ->                                -- timeout_msec+    Maybe (b) ->                            -- fd_list+    Maybe (c) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+dBusConnectionCallWithUnixFdList _obj bus_name object_path interface_name method_name parameters reply_type flags timeout_msec fd_list cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeBus_name <- case bus_name of+        Nothing -> return nullPtr+        Just jBus_name -> do+            jBus_name' <- textToCString jBus_name+            return jBus_name'+    object_path' <- textToCString object_path+    interface_name' <- textToCString interface_name+    method_name' <- textToCString method_name+    maybeParameters <- case parameters of+        Nothing -> return nullPtr+        Just jParameters -> do+            let jParameters' = unsafeManagedPtrGetPtr jParameters+            return jParameters'+    maybeReply_type <- case reply_type of+        Nothing -> return nullPtr+        Just jReply_type -> do+            let jReply_type' = unsafeManagedPtrGetPtr jReply_type+            return jReply_type'+    let flags' = gflagsToWord flags+    maybeFd_list <- case fd_list of+        Nothing -> return nullPtr+        Just jFd_list -> do+            let jFd_list' = unsafeManagedPtrCastPtr jFd_list+            return jFd_list'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_dbus_connection_call_with_unix_fd_list _obj' maybeBus_name object_path' interface_name' method_name' maybeParameters maybeReply_type flags' timeout_msec maybeFd_list maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust reply_type touchManagedPtr+    whenJust fd_list touchManagedPtr+    whenJust cancellable touchManagedPtr+    freeMem maybeBus_name+    freeMem object_path'+    freeMem interface_name'+    freeMem method_name'+    return ()++-- method DBusConnection::call_with_unix_fd_list_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "out_fd_list", argType = TInterface "Gio" "UnixFDList", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TVariant+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_connection_call_with_unix_fd_list_finish" g_dbus_connection_call_with_unix_fd_list_finish :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    Ptr (Ptr UnixFDList) ->                 -- out_fd_list : TInterface "Gio" "UnixFDList"+    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr GVariant)+++dBusConnectionCallWithUnixFdListFinish ::+    (MonadIO m, DBusConnectionK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- res+    m (GVariant,UnixFDList)+dBusConnectionCallWithUnixFdListFinish _obj res = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    out_fd_list <- allocMem :: IO (Ptr (Ptr UnixFDList))+    let res' = unsafeManagedPtrCastPtr res+    onException (do+        result <- propagateGError $ g_dbus_connection_call_with_unix_fd_list_finish _obj' out_fd_list res'+        checkUnexpectedReturnNULL "g_dbus_connection_call_with_unix_fd_list_finish" result+        result' <- wrapGVariantPtr result+        out_fd_list' <- peek out_fd_list+        out_fd_list'' <- (wrapObject UnixFDList) out_fd_list'+        touchManagedPtr _obj+        touchManagedPtr res+        freeMem out_fd_list+        return (result', out_fd_list'')+     ) (do+        freeMem out_fd_list+     )++-- method DBusConnection::call_with_unix_fd_list_sync+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "bus_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "method_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameters", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "reply_type", argType = TInterface "GLib" "VariantType", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusCallFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "timeout_msec", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fd_list", argType = TInterface "Gio" "UnixFDList", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "out_fd_list", argType = TInterface "Gio" "UnixFDList", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "bus_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "method_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameters", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "reply_type", argType = TInterface "GLib" "VariantType", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusCallFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "timeout_msec", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fd_list", argType = TInterface "Gio" "UnixFDList", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TVariant+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_connection_call_with_unix_fd_list_sync" g_dbus_connection_call_with_unix_fd_list_sync :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    CString ->                              -- bus_name : TBasicType TUTF8+    CString ->                              -- object_path : TBasicType TUTF8+    CString ->                              -- interface_name : TBasicType TUTF8+    CString ->                              -- method_name : TBasicType TUTF8+    Ptr GVariant ->                         -- parameters : TVariant+    Ptr GLib.VariantType ->                 -- reply_type : TInterface "GLib" "VariantType"+    CUInt ->                                -- flags : TInterface "Gio" "DBusCallFlags"+    Int32 ->                                -- timeout_msec : TBasicType TInt32+    Ptr UnixFDList ->                       -- fd_list : TInterface "Gio" "UnixFDList"+    Ptr (Ptr UnixFDList) ->                 -- out_fd_list : TInterface "Gio" "UnixFDList"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr GVariant)+++dBusConnectionCallWithUnixFdListSync ::+    (MonadIO m, DBusConnectionK a, UnixFDListK b, CancellableK c) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- bus_name+    T.Text ->                               -- object_path+    T.Text ->                               -- interface_name+    T.Text ->                               -- method_name+    Maybe (GVariant) ->                     -- parameters+    Maybe (GLib.VariantType) ->             -- reply_type+    [DBusCallFlags] ->                      -- flags+    Int32 ->                                -- timeout_msec+    Maybe (b) ->                            -- fd_list+    Maybe (c) ->                            -- cancellable+    m (GVariant,UnixFDList)+dBusConnectionCallWithUnixFdListSync _obj bus_name object_path interface_name method_name parameters reply_type flags timeout_msec fd_list cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeBus_name <- case bus_name of+        Nothing -> return nullPtr+        Just jBus_name -> do+            jBus_name' <- textToCString jBus_name+            return jBus_name'+    object_path' <- textToCString object_path+    interface_name' <- textToCString interface_name+    method_name' <- textToCString method_name+    maybeParameters <- case parameters of+        Nothing -> return nullPtr+        Just jParameters -> do+            let jParameters' = unsafeManagedPtrGetPtr jParameters+            return jParameters'+    maybeReply_type <- case reply_type of+        Nothing -> return nullPtr+        Just jReply_type -> do+            let jReply_type' = unsafeManagedPtrGetPtr jReply_type+            return jReply_type'+    let flags' = gflagsToWord flags+    maybeFd_list <- case fd_list of+        Nothing -> return nullPtr+        Just jFd_list -> do+            let jFd_list' = unsafeManagedPtrCastPtr jFd_list+            return jFd_list'+    out_fd_list <- allocMem :: IO (Ptr (Ptr UnixFDList))+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_dbus_connection_call_with_unix_fd_list_sync _obj' maybeBus_name object_path' interface_name' method_name' maybeParameters maybeReply_type flags' timeout_msec maybeFd_list out_fd_list maybeCancellable+        checkUnexpectedReturnNULL "g_dbus_connection_call_with_unix_fd_list_sync" result+        result' <- wrapGVariantPtr result+        out_fd_list' <- peek out_fd_list+        out_fd_list'' <- (wrapObject UnixFDList) out_fd_list'+        touchManagedPtr _obj+        whenJust reply_type touchManagedPtr+        whenJust fd_list touchManagedPtr+        whenJust cancellable touchManagedPtr+        freeMem maybeBus_name+        freeMem object_path'+        freeMem interface_name'+        freeMem method_name'+        freeMem out_fd_list+        return (result', out_fd_list'')+     ) (do+        freeMem maybeBus_name+        freeMem object_path'+        freeMem interface_name'+        freeMem method_name'+        freeMem out_fd_list+     )++-- method DBusConnection::close+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_connection_close" g_dbus_connection_close :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++dBusConnectionClose ::+    (MonadIO m, DBusConnectionK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+dBusConnectionClose _obj cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_dbus_connection_close _obj' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method DBusConnection::close_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_connection_close_finish" g_dbus_connection_close_finish :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++dBusConnectionCloseFinish ::+    (MonadIO m, DBusConnectionK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- res+    m ()+dBusConnectionCloseFinish _obj res = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let res' = unsafeManagedPtrCastPtr res+    onException (do+        _ <- propagateGError $ g_dbus_connection_close_finish _obj' res'+        touchManagedPtr _obj+        touchManagedPtr res+        return ()+     ) (do+        return ()+     )++-- method DBusConnection::close_sync+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_connection_close_sync" g_dbus_connection_close_sync :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++dBusConnectionCloseSync ::+    (MonadIO m, DBusConnectionK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m ()+dBusConnectionCloseSync _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_dbus_connection_close_sync _obj' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method DBusConnection::emit_signal+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "destination_bus_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "signal_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameters", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "destination_bus_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "signal_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameters", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_connection_emit_signal" g_dbus_connection_emit_signal :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    CString ->                              -- destination_bus_name : TBasicType TUTF8+    CString ->                              -- object_path : TBasicType TUTF8+    CString ->                              -- interface_name : TBasicType TUTF8+    CString ->                              -- signal_name : TBasicType TUTF8+    Ptr GVariant ->                         -- parameters : TVariant+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++dBusConnectionEmitSignal ::+    (MonadIO m, DBusConnectionK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- destination_bus_name+    T.Text ->                               -- object_path+    T.Text ->                               -- interface_name+    T.Text ->                               -- signal_name+    Maybe (GVariant) ->                     -- parameters+    m ()+dBusConnectionEmitSignal _obj destination_bus_name object_path interface_name signal_name parameters = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeDestination_bus_name <- case destination_bus_name of+        Nothing -> return nullPtr+        Just jDestination_bus_name -> do+            jDestination_bus_name' <- textToCString jDestination_bus_name+            return jDestination_bus_name'+    object_path' <- textToCString object_path+    interface_name' <- textToCString interface_name+    signal_name' <- textToCString signal_name+    maybeParameters <- case parameters of+        Nothing -> return nullPtr+        Just jParameters -> do+            let jParameters' = unsafeManagedPtrGetPtr jParameters+            return jParameters'+    onException (do+        _ <- propagateGError $ g_dbus_connection_emit_signal _obj' maybeDestination_bus_name object_path' interface_name' signal_name' maybeParameters+        touchManagedPtr _obj+        freeMem maybeDestination_bus_name+        freeMem object_path'+        freeMem interface_name'+        freeMem signal_name'+        return ()+     ) (do+        freeMem maybeDestination_bus_name+        freeMem object_path'+        freeMem interface_name'+        freeMem signal_name'+     )++-- method DBusConnection::export_action_group+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_group", argType = TInterface "Gio" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_group", argType = TInterface "Gio" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_connection_export_action_group" g_dbus_connection_export_action_group :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    CString ->                              -- object_path : TBasicType TUTF8+    Ptr ActionGroup ->                      -- action_group : TInterface "Gio" "ActionGroup"+    Ptr (Ptr GError) ->                     -- error+    IO Word32+++dBusConnectionExportActionGroup ::+    (MonadIO m, DBusConnectionK a, ActionGroupK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- object_path+    b ->                                    -- action_group+    m Word32+dBusConnectionExportActionGroup _obj object_path action_group = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    object_path' <- textToCString object_path+    let action_group' = unsafeManagedPtrCastPtr action_group+    onException (do+        result <- propagateGError $ g_dbus_connection_export_action_group _obj' object_path' action_group'+        touchManagedPtr _obj+        touchManagedPtr action_group+        freeMem object_path'+        return result+     ) (do+        freeMem object_path'+     )++-- method DBusConnection::export_menu_model+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "menu", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "menu", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_connection_export_menu_model" g_dbus_connection_export_menu_model :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    CString ->                              -- object_path : TBasicType TUTF8+    Ptr MenuModel ->                        -- menu : TInterface "Gio" "MenuModel"+    Ptr (Ptr GError) ->                     -- error+    IO Word32+++dBusConnectionExportMenuModel ::+    (MonadIO m, DBusConnectionK a, MenuModelK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- object_path+    b ->                                    -- menu+    m Word32+dBusConnectionExportMenuModel _obj object_path menu = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    object_path' <- textToCString object_path+    let menu' = unsafeManagedPtrCastPtr menu+    onException (do+        result <- propagateGError $ g_dbus_connection_export_menu_model _obj' object_path' menu'+        touchManagedPtr _obj+        touchManagedPtr menu+        freeMem object_path'+        return result+     ) (do+        freeMem object_path'+     )++-- method DBusConnection::flush+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_connection_flush" g_dbus_connection_flush :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++dBusConnectionFlush ::+    (MonadIO m, DBusConnectionK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+dBusConnectionFlush _obj cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_dbus_connection_flush _obj' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method DBusConnection::flush_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_connection_flush_finish" g_dbus_connection_flush_finish :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++dBusConnectionFlushFinish ::+    (MonadIO m, DBusConnectionK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- res+    m ()+dBusConnectionFlushFinish _obj res = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let res' = unsafeManagedPtrCastPtr res+    onException (do+        _ <- propagateGError $ g_dbus_connection_flush_finish _obj' res'+        touchManagedPtr _obj+        touchManagedPtr res+        return ()+     ) (do+        return ()+     )++-- method DBusConnection::flush_sync+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_connection_flush_sync" g_dbus_connection_flush_sync :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++dBusConnectionFlushSync ::+    (MonadIO m, DBusConnectionK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m ()+dBusConnectionFlushSync _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_dbus_connection_flush_sync _obj' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method DBusConnection::get_capabilities+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusCapabilityFlags"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_connection_get_capabilities" g_dbus_connection_get_capabilities :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    IO CUInt+++dBusConnectionGetCapabilities ::+    (MonadIO m, DBusConnectionK a) =>+    a ->                                    -- _obj+    m [DBusCapabilityFlags]+dBusConnectionGetCapabilities _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_connection_get_capabilities _obj'+    let result' = wordToGFlags result+    touchManagedPtr _obj+    return result'++-- method DBusConnection::get_exit_on_close+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_connection_get_exit_on_close" g_dbus_connection_get_exit_on_close :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    IO CInt+++dBusConnectionGetExitOnClose ::+    (MonadIO m, DBusConnectionK a) =>+    a ->                                    -- _obj+    m Bool+dBusConnectionGetExitOnClose _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_connection_get_exit_on_close _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method DBusConnection::get_guid+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_connection_get_guid" g_dbus_connection_get_guid :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    IO CString+++dBusConnectionGetGuid ::+    (MonadIO m, DBusConnectionK a) =>+    a ->                                    -- _obj+    m T.Text+dBusConnectionGetGuid _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_connection_get_guid _obj'+    checkUnexpectedReturnNULL "g_dbus_connection_get_guid" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method DBusConnection::get_last_serial+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_connection_get_last_serial" g_dbus_connection_get_last_serial :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    IO Word32+++dBusConnectionGetLastSerial ::+    (MonadIO m, DBusConnectionK a) =>+    a ->                                    -- _obj+    m Word32+dBusConnectionGetLastSerial _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_connection_get_last_serial _obj'+    touchManagedPtr _obj+    return result++-- method DBusConnection::get_peer_credentials+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Credentials"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_connection_get_peer_credentials" g_dbus_connection_get_peer_credentials :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    IO (Ptr Credentials)+++dBusConnectionGetPeerCredentials ::+    (MonadIO m, DBusConnectionK a) =>+    a ->                                    -- _obj+    m Credentials+dBusConnectionGetPeerCredentials _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_connection_get_peer_credentials _obj'+    checkUnexpectedReturnNULL "g_dbus_connection_get_peer_credentials" result+    result' <- (newObject Credentials) result+    touchManagedPtr _obj+    return result'++-- method DBusConnection::get_stream+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "IOStream"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_connection_get_stream" g_dbus_connection_get_stream :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    IO (Ptr IOStream)+++dBusConnectionGetStream ::+    (MonadIO m, DBusConnectionK a) =>+    a ->                                    -- _obj+    m IOStream+dBusConnectionGetStream _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_connection_get_stream _obj'+    checkUnexpectedReturnNULL "g_dbus_connection_get_stream" result+    result' <- (newObject IOStream) result+    touchManagedPtr _obj+    return result'++-- method DBusConnection::get_unique_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_connection_get_unique_name" g_dbus_connection_get_unique_name :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    IO CString+++dBusConnectionGetUniqueName ::+    (MonadIO m, DBusConnectionK a) =>+    a ->                                    -- _obj+    m T.Text+dBusConnectionGetUniqueName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_connection_get_unique_name _obj'+    checkUnexpectedReturnNULL "g_dbus_connection_get_unique_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method DBusConnection::is_closed+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_connection_is_closed" g_dbus_connection_is_closed :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    IO CInt+++dBusConnectionIsClosed ::+    (MonadIO m, DBusConnectionK a) =>+    a ->                                    -- _obj+    m Bool+dBusConnectionIsClosed _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_connection_is_closed _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method DBusConnection::register_object+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_info", argType = TInterface "Gio" "DBusInterfaceInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "method_call_closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "get_property_closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "set_property_closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_info", argType = TInterface "Gio" "DBusInterfaceInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "method_call_closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "get_property_closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "set_property_closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_connection_register_object_with_closures" g_dbus_connection_register_object_with_closures :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    CString ->                              -- object_path : TBasicType TUTF8+    Ptr DBusInterfaceInfo ->                -- interface_info : TInterface "Gio" "DBusInterfaceInfo"+    Ptr Closure ->                          -- method_call_closure : TInterface "GObject" "Closure"+    Ptr Closure ->                          -- get_property_closure : TInterface "GObject" "Closure"+    Ptr Closure ->                          -- set_property_closure : TInterface "GObject" "Closure"+    Ptr (Ptr GError) ->                     -- error+    IO Word32+++dBusConnectionRegisterObject ::+    (MonadIO m, DBusConnectionK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- object_path+    DBusInterfaceInfo ->                    -- interface_info+    Maybe (Closure) ->                      -- method_call_closure+    Maybe (Closure) ->                      -- get_property_closure+    Maybe (Closure) ->                      -- set_property_closure+    m Word32+dBusConnectionRegisterObject _obj object_path interface_info method_call_closure get_property_closure_ set_property_closure_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    object_path' <- textToCString object_path+    let interface_info' = unsafeManagedPtrGetPtr interface_info+    maybeMethod_call_closure <- case method_call_closure of+        Nothing -> return nullPtr+        Just jMethod_call_closure -> do+            let jMethod_call_closure' = unsafeManagedPtrGetPtr jMethod_call_closure+            return jMethod_call_closure'+    maybeGet_property_closure_ <- case get_property_closure_ of+        Nothing -> return nullPtr+        Just jGet_property_closure_ -> do+            let jGet_property_closure_' = unsafeManagedPtrGetPtr jGet_property_closure_+            return jGet_property_closure_'+    maybeSet_property_closure_ <- case set_property_closure_ of+        Nothing -> return nullPtr+        Just jSet_property_closure_ -> do+            let jSet_property_closure_' = unsafeManagedPtrGetPtr jSet_property_closure_+            return jSet_property_closure_'+    onException (do+        result <- propagateGError $ g_dbus_connection_register_object_with_closures _obj' object_path' interface_info' maybeMethod_call_closure maybeGet_property_closure_ maybeSet_property_closure_+        touchManagedPtr _obj+        touchManagedPtr interface_info+        whenJust method_call_closure touchManagedPtr+        whenJust get_property_closure_ touchManagedPtr+        whenJust set_property_closure_ touchManagedPtr+        freeMem object_path'+        return result+     ) (do+        freeMem object_path'+     )++-- method DBusConnection::register_subtree+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "vtable", argType = TInterface "Gio" "DBusSubtreeVTable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusSubtreeFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data_free_func", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "vtable", argType = TInterface "Gio" "DBusSubtreeVTable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusSubtreeFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data_free_func", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_connection_register_subtree" g_dbus_connection_register_subtree :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    CString ->                              -- object_path : TBasicType TUTF8+    Ptr DBusSubtreeVTable ->                -- vtable : TInterface "Gio" "DBusSubtreeVTable"+    CUInt ->                                -- flags : TInterface "Gio" "DBusSubtreeFlags"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- user_data_free_func : TInterface "GLib" "DestroyNotify"+    Ptr (Ptr GError) ->                     -- error+    IO Word32+++dBusConnectionRegisterSubtree ::+    (MonadIO m, DBusConnectionK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- object_path+    DBusSubtreeVTable ->                    -- vtable+    [DBusSubtreeFlags] ->                   -- flags+    Ptr () ->                               -- user_data+    GLib.DestroyNotify ->                   -- user_data_free_func+    m Word32+dBusConnectionRegisterSubtree _obj object_path vtable flags user_data user_data_free_func = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    object_path' <- textToCString object_path+    let vtable' = unsafeManagedPtrGetPtr vtable+    let flags' = gflagsToWord flags+    ptruser_data_free_func <- callocMem :: IO (Ptr (FunPtr GLib.DestroyNotifyC))+    user_data_free_func' <- GLib.mkDestroyNotify (GLib.destroyNotifyWrapper (Just ptruser_data_free_func) user_data_free_func)+    poke ptruser_data_free_func user_data_free_func'+    onException (do+        result <- propagateGError $ g_dbus_connection_register_subtree _obj' object_path' vtable' flags' user_data user_data_free_func'+        touchManagedPtr _obj+        touchManagedPtr vtable+        freeMem object_path'+        return result+     ) (do+        freeMem object_path'+     )++-- method DBusConnection::remove_filter+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filter_id", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filter_id", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_connection_remove_filter" g_dbus_connection_remove_filter :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    Word32 ->                               -- filter_id : TBasicType TUInt32+    IO ()+++dBusConnectionRemoveFilter ::+    (MonadIO m, DBusConnectionK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- filter_id+    m ()+dBusConnectionRemoveFilter _obj filter_id = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_dbus_connection_remove_filter _obj' filter_id+    touchManagedPtr _obj+    return ()++-- method DBusConnection::send_message+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "message", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusSendMessageFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "out_serial", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "message", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusSendMessageFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_connection_send_message" g_dbus_connection_send_message :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    Ptr DBusMessage ->                      -- message : TInterface "Gio" "DBusMessage"+    CUInt ->                                -- flags : TInterface "Gio" "DBusSendMessageFlags"+    Ptr Word32 ->                           -- out_serial : TBasicType TUInt32+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++dBusConnectionSendMessage ::+    (MonadIO m, DBusConnectionK a, DBusMessageK b) =>+    a ->                                    -- _obj+    b ->                                    -- message+    [DBusSendMessageFlags] ->               -- flags+    m (Word32)+dBusConnectionSendMessage _obj message flags = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let message' = unsafeManagedPtrCastPtr message+    let flags' = gflagsToWord flags+    out_serial <- allocMem :: IO (Ptr Word32)+    onException (do+        _ <- propagateGError $ g_dbus_connection_send_message _obj' message' flags' out_serial+        out_serial' <- peek out_serial+        touchManagedPtr _obj+        touchManagedPtr message+        freeMem out_serial+        return out_serial'+     ) (do+        freeMem out_serial+     )++-- method DBusConnection::send_message_with_reply+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "message", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusSendMessageFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "timeout_msec", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "out_serial", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 7, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "message", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusSendMessageFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "timeout_msec", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 7, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_connection_send_message_with_reply" g_dbus_connection_send_message_with_reply :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    Ptr DBusMessage ->                      -- message : TInterface "Gio" "DBusMessage"+    CUInt ->                                -- flags : TInterface "Gio" "DBusSendMessageFlags"+    Int32 ->                                -- timeout_msec : TBasicType TInt32+    Ptr Word32 ->                           -- out_serial : TBasicType TUInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++dBusConnectionSendMessageWithReply ::+    (MonadIO m, DBusConnectionK a, DBusMessageK b, CancellableK c) =>+    a ->                                    -- _obj+    b ->                                    -- message+    [DBusSendMessageFlags] ->               -- flags+    Int32 ->                                -- timeout_msec+    Maybe (c) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m (Word32)+dBusConnectionSendMessageWithReply _obj message flags timeout_msec cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let message' = unsafeManagedPtrCastPtr message+    let flags' = gflagsToWord flags+    out_serial <- allocMem :: IO (Ptr Word32)+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_dbus_connection_send_message_with_reply _obj' message' flags' timeout_msec out_serial maybeCancellable maybeCallback user_data+    out_serial' <- peek out_serial+    touchManagedPtr _obj+    touchManagedPtr message+    whenJust cancellable touchManagedPtr+    freeMem out_serial+    return out_serial'++-- method DBusConnection::send_message_with_reply_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusMessage"+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_connection_send_message_with_reply_finish" g_dbus_connection_send_message_with_reply_finish :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr DBusMessage)+++dBusConnectionSendMessageWithReplyFinish ::+    (MonadIO m, DBusConnectionK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- res+    m DBusMessage+dBusConnectionSendMessageWithReplyFinish _obj res = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let res' = unsafeManagedPtrCastPtr res+    onException (do+        result <- propagateGError $ g_dbus_connection_send_message_with_reply_finish _obj' res'+        checkUnexpectedReturnNULL "g_dbus_connection_send_message_with_reply_finish" result+        result' <- (wrapObject DBusMessage) result+        touchManagedPtr _obj+        touchManagedPtr res+        return result'+     ) (do+        return ()+     )++-- method DBusConnection::send_message_with_reply_sync+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "message", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusSendMessageFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "timeout_msec", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "out_serial", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "message", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusSendMessageFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "timeout_msec", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusMessage"+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_connection_send_message_with_reply_sync" g_dbus_connection_send_message_with_reply_sync :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    Ptr DBusMessage ->                      -- message : TInterface "Gio" "DBusMessage"+    CUInt ->                                -- flags : TInterface "Gio" "DBusSendMessageFlags"+    Int32 ->                                -- timeout_msec : TBasicType TInt32+    Ptr Word32 ->                           -- out_serial : TBasicType TUInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr DBusMessage)+++dBusConnectionSendMessageWithReplySync ::+    (MonadIO m, DBusConnectionK a, DBusMessageK b, CancellableK c) =>+    a ->                                    -- _obj+    b ->                                    -- message+    [DBusSendMessageFlags] ->               -- flags+    Int32 ->                                -- timeout_msec+    Maybe (c) ->                            -- cancellable+    m (DBusMessage,Word32)+dBusConnectionSendMessageWithReplySync _obj message flags timeout_msec cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let message' = unsafeManagedPtrCastPtr message+    let flags' = gflagsToWord flags+    out_serial <- allocMem :: IO (Ptr Word32)+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_dbus_connection_send_message_with_reply_sync _obj' message' flags' timeout_msec out_serial maybeCancellable+        checkUnexpectedReturnNULL "g_dbus_connection_send_message_with_reply_sync" result+        result' <- (wrapObject DBusMessage) result+        out_serial' <- peek out_serial+        touchManagedPtr _obj+        touchManagedPtr message+        whenJust cancellable touchManagedPtr+        freeMem out_serial+        return (result', out_serial')+     ) (do+        freeMem out_serial+     )++-- method DBusConnection::set_exit_on_close+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "exit_on_close", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "exit_on_close", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_connection_set_exit_on_close" g_dbus_connection_set_exit_on_close :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    CInt ->                                 -- exit_on_close : TBasicType TBoolean+    IO ()+++dBusConnectionSetExitOnClose ::+    (MonadIO m, DBusConnectionK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- exit_on_close+    m ()+dBusConnectionSetExitOnClose _obj exit_on_close = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let exit_on_close' = (fromIntegral . fromEnum) exit_on_close+    g_dbus_connection_set_exit_on_close _obj' exit_on_close'+    touchManagedPtr _obj+    return ()++-- method DBusConnection::signal_subscribe+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sender", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "member", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "arg0", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusSignalFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "DBusSignalCallback", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 8, argDestroy = 9, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data_free_func", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sender", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "member", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "arg0", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusSignalFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "DBusSignalCallback", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 8, argDestroy = 9, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_connection_signal_subscribe" g_dbus_connection_signal_subscribe :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    CString ->                              -- sender : TBasicType TUTF8+    CString ->                              -- interface_name : TBasicType TUTF8+    CString ->                              -- member : TBasicType TUTF8+    CString ->                              -- object_path : TBasicType TUTF8+    CString ->                              -- arg0 : TBasicType TUTF8+    CUInt ->                                -- flags : TInterface "Gio" "DBusSignalFlags"+    FunPtr DBusSignalCallbackC ->           -- callback : TInterface "Gio" "DBusSignalCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- user_data_free_func : TInterface "GLib" "DestroyNotify"+    IO Word32+++dBusConnectionSignalSubscribe ::+    (MonadIO m, DBusConnectionK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- sender+    Maybe (T.Text) ->                       -- interface_name+    Maybe (T.Text) ->                       -- member+    Maybe (T.Text) ->                       -- object_path+    Maybe (T.Text) ->                       -- arg0+    [DBusSignalFlags] ->                    -- flags+    DBusSignalCallback ->                   -- callback+    m Word32+dBusConnectionSignalSubscribe _obj sender interface_name member object_path arg0 flags callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeSender <- case sender of+        Nothing -> return nullPtr+        Just jSender -> do+            jSender' <- textToCString jSender+            return jSender'+    maybeInterface_name <- case interface_name of+        Nothing -> return nullPtr+        Just jInterface_name -> do+            jInterface_name' <- textToCString jInterface_name+            return jInterface_name'+    maybeMember <- case member of+        Nothing -> return nullPtr+        Just jMember -> do+            jMember' <- textToCString jMember+            return jMember'+    maybeObject_path <- case object_path of+        Nothing -> return nullPtr+        Just jObject_path -> do+            jObject_path' <- textToCString jObject_path+            return jObject_path'+    maybeArg0 <- case arg0 of+        Nothing -> return nullPtr+        Just jArg0 -> do+            jArg0' <- textToCString jArg0+            return jArg0'+    let flags' = gflagsToWord flags+    callback' <- mkDBusSignalCallback (dBusSignalCallbackWrapper Nothing callback)+    let user_data = castFunPtrToPtr callback'+    let user_data_free_func = safeFreeFunPtrPtr+    result <- g_dbus_connection_signal_subscribe _obj' maybeSender maybeInterface_name maybeMember maybeObject_path maybeArg0 flags' callback' user_data user_data_free_func+    touchManagedPtr _obj+    freeMem maybeSender+    freeMem maybeInterface_name+    freeMem maybeMember+    freeMem maybeObject_path+    freeMem maybeArg0+    return result++-- method DBusConnection::signal_unsubscribe+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "subscription_id", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "subscription_id", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_connection_signal_unsubscribe" g_dbus_connection_signal_unsubscribe :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    Word32 ->                               -- subscription_id : TBasicType TUInt32+    IO ()+++dBusConnectionSignalUnsubscribe ::+    (MonadIO m, DBusConnectionK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- subscription_id+    m ()+dBusConnectionSignalUnsubscribe _obj subscription_id = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_dbus_connection_signal_unsubscribe _obj' subscription_id+    touchManagedPtr _obj+    return ()++-- method DBusConnection::start_message_processing+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_connection_start_message_processing" g_dbus_connection_start_message_processing :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    IO ()+++dBusConnectionStartMessageProcessing ::+    (MonadIO m, DBusConnectionK a) =>+    a ->                                    -- _obj+    m ()+dBusConnectionStartMessageProcessing _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_dbus_connection_start_message_processing _obj'+    touchManagedPtr _obj+    return ()++-- method DBusConnection::unexport_action_group+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "export_id", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "export_id", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_connection_unexport_action_group" g_dbus_connection_unexport_action_group :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    Word32 ->                               -- export_id : TBasicType TUInt32+    IO ()+++dBusConnectionUnexportActionGroup ::+    (MonadIO m, DBusConnectionK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- export_id+    m ()+dBusConnectionUnexportActionGroup _obj export_id = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_dbus_connection_unexport_action_group _obj' export_id+    touchManagedPtr _obj+    return ()++-- method DBusConnection::unexport_menu_model+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "export_id", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "export_id", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_connection_unexport_menu_model" g_dbus_connection_unexport_menu_model :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    Word32 ->                               -- export_id : TBasicType TUInt32+    IO ()+++dBusConnectionUnexportMenuModel ::+    (MonadIO m, DBusConnectionK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- export_id+    m ()+dBusConnectionUnexportMenuModel _obj export_id = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_dbus_connection_unexport_menu_model _obj' export_id+    touchManagedPtr _obj+    return ()++-- method DBusConnection::unregister_object+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "registration_id", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "registration_id", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_connection_unregister_object" g_dbus_connection_unregister_object :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    Word32 ->                               -- registration_id : TBasicType TUInt32+    IO CInt+++dBusConnectionUnregisterObject ::+    (MonadIO m, DBusConnectionK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- registration_id+    m Bool+dBusConnectionUnregisterObject _obj registration_id = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_connection_unregister_object _obj' registration_id+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method DBusConnection::unregister_subtree+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "registration_id", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "registration_id", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_connection_unregister_subtree" g_dbus_connection_unregister_subtree :: +    Ptr DBusConnection ->                   -- _obj : TInterface "Gio" "DBusConnection"+    Word32 ->                               -- registration_id : TBasicType TUInt32+    IO CInt+++dBusConnectionUnregisterSubtree ::+    (MonadIO m, DBusConnectionK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- registration_id+    m Bool+dBusConnectionUnregisterSubtree _obj registration_id = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_connection_unregister_subtree _obj' registration_id+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method DBusConnection::new+-- method type : MemberFunction+-- Args : [Arg {argName = "stream", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "guid", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusConnectionFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "observer", argType = TInterface "Gio" "DBusAuthObserver", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "stream", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "guid", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusConnectionFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "observer", argType = TInterface "Gio" "DBusAuthObserver", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_connection_new" g_dbus_connection_new :: +    Ptr IOStream ->                         -- stream : TInterface "Gio" "IOStream"+    CString ->                              -- guid : TBasicType TUTF8+    CUInt ->                                -- flags : TInterface "Gio" "DBusConnectionFlags"+    Ptr DBusAuthObserver ->                 -- observer : TInterface "Gio" "DBusAuthObserver"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++dBusConnectionNew ::+    (MonadIO m, IOStreamK a, DBusAuthObserverK b, CancellableK c) =>+    a ->                                    -- stream+    Maybe (T.Text) ->                       -- guid+    [DBusConnectionFlags] ->                -- flags+    Maybe (b) ->                            -- observer+    Maybe (c) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+dBusConnectionNew stream guid flags observer cancellable callback = liftIO $ do+    let stream' = unsafeManagedPtrCastPtr stream+    maybeGuid <- case guid of+        Nothing -> return nullPtr+        Just jGuid -> do+            jGuid' <- textToCString jGuid+            return jGuid'+    let flags' = gflagsToWord flags+    maybeObserver <- case observer of+        Nothing -> return nullPtr+        Just jObserver -> do+            let jObserver' = unsafeManagedPtrCastPtr jObserver+            return jObserver'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_dbus_connection_new stream' maybeGuid flags' maybeObserver maybeCancellable maybeCallback user_data+    touchManagedPtr stream+    whenJust observer touchManagedPtr+    whenJust cancellable touchManagedPtr+    freeMem maybeGuid+    return ()++-- method DBusConnection::new_for_address+-- method type : MemberFunction+-- Args : [Arg {argName = "address", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusConnectionFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "observer", argType = TInterface "Gio" "DBusAuthObserver", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "address", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusConnectionFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "observer", argType = TInterface "Gio" "DBusAuthObserver", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_connection_new_for_address" g_dbus_connection_new_for_address :: +    CString ->                              -- address : TBasicType TUTF8+    CUInt ->                                -- flags : TInterface "Gio" "DBusConnectionFlags"+    Ptr DBusAuthObserver ->                 -- observer : TInterface "Gio" "DBusAuthObserver"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++dBusConnectionNewForAddress ::+    (MonadIO m, DBusAuthObserverK a, CancellableK b) =>+    T.Text ->                               -- address+    [DBusConnectionFlags] ->                -- flags+    Maybe (a) ->                            -- observer+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+dBusConnectionNewForAddress address flags observer cancellable callback = liftIO $ do+    address' <- textToCString address+    let flags' = gflagsToWord flags+    maybeObserver <- case observer of+        Nothing -> return nullPtr+        Just jObserver -> do+            let jObserver' = unsafeManagedPtrCastPtr jObserver+            return jObserver'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_dbus_connection_new_for_address address' flags' maybeObserver maybeCancellable maybeCallback user_data+    whenJust observer touchManagedPtr+    whenJust cancellable touchManagedPtr+    freeMem address'+    return ()++
+ GI/Gio/Objects/DBusConnection.hs-boot view
@@ -0,0 +1,23 @@+module GI.Gio.Objects.DBusConnection where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype DBusConnection = DBusConnection (ForeignPtr DBusConnection)+instance GObject DBusConnection where+class GObject o => DBusConnectionK o+instance (GObject o, IsDescendantOf DBusConnection o) => DBusConnectionK o+data DBusConnectionAddressPropertyInfo+data DBusConnectionAuthenticationObserverPropertyInfo+data DBusConnectionCapabilitiesPropertyInfo+data DBusConnectionClosedPropertyInfo+data DBusConnectionExitOnClosePropertyInfo+data DBusConnectionFlagsPropertyInfo+data DBusConnectionGuidPropertyInfo+data DBusConnectionStreamPropertyInfo+data DBusConnectionUniqueNamePropertyInfo+data DBusConnectionClosedSignalInfo
+ GI/Gio/Objects/DBusInterfaceSkeleton.hs view
@@ -0,0 +1,533 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.DBusInterfaceSkeleton+    ( ++-- * Exported types+    DBusInterfaceSkeleton(..)               ,+    DBusInterfaceSkeletonK                  ,+    toDBusInterfaceSkeleton                 ,+    noDBusInterfaceSkeleton                 ,+++ -- * Methods+-- ** dBusInterfaceSkeletonExport+    dBusInterfaceSkeletonExport             ,+++-- ** dBusInterfaceSkeletonFlush+    dBusInterfaceSkeletonFlush              ,+++-- ** dBusInterfaceSkeletonGetConnection+    dBusInterfaceSkeletonGetConnection      ,+++-- ** dBusInterfaceSkeletonGetConnections+    dBusInterfaceSkeletonGetConnections     ,+++-- ** dBusInterfaceSkeletonGetFlags+    dBusInterfaceSkeletonGetFlags           ,+++-- ** dBusInterfaceSkeletonGetInfo+    dBusInterfaceSkeletonGetInfo            ,+++-- ** dBusInterfaceSkeletonGetObjectPath+    dBusInterfaceSkeletonGetObjectPath      ,+++-- ** dBusInterfaceSkeletonGetProperties+    dBusInterfaceSkeletonGetProperties      ,+++-- ** dBusInterfaceSkeletonHasConnection+    dBusInterfaceSkeletonHasConnection      ,+++-- ** dBusInterfaceSkeletonSetFlags+    dBusInterfaceSkeletonSetFlags           ,+++-- ** dBusInterfaceSkeletonUnexport+    dBusInterfaceSkeletonUnexport           ,+++-- ** dBusInterfaceSkeletonUnexportFromConnection+    dBusInterfaceSkeletonUnexportFromConnection,+++++ -- * Properties+-- ** GFlags+    DBusInterfaceSkeletonGFlagsPropertyInfo ,+    constructDBusInterfaceSkeletonGFlags    ,+    getDBusInterfaceSkeletonGFlags          ,+    setDBusInterfaceSkeletonGFlags          ,+++++ -- * Signals+-- ** GAuthorizeMethod+    DBusInterfaceSkeletonGAuthorizeMethodCallback,+    DBusInterfaceSkeletonGAuthorizeMethodCallbackC,+    DBusInterfaceSkeletonGAuthorizeMethodSignalInfo,+    afterDBusInterfaceSkeletonGAuthorizeMethod,+    dBusInterfaceSkeletonGAuthorizeMethodCallbackWrapper,+    dBusInterfaceSkeletonGAuthorizeMethodClosure,+    mkDBusInterfaceSkeletonGAuthorizeMethodCallback,+    noDBusInterfaceSkeletonGAuthorizeMethodCallback,+    onDBusInterfaceSkeletonGAuthorizeMethod ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype DBusInterfaceSkeleton = DBusInterfaceSkeleton (ForeignPtr DBusInterfaceSkeleton)+foreign import ccall "g_dbus_interface_skeleton_get_type"+    c_g_dbus_interface_skeleton_get_type :: IO GType++type instance ParentTypes DBusInterfaceSkeleton = DBusInterfaceSkeletonParentTypes+type DBusInterfaceSkeletonParentTypes = '[GObject.Object, DBusInterface]++instance GObject DBusInterfaceSkeleton where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_dbus_interface_skeleton_get_type+    ++class GObject o => DBusInterfaceSkeletonK o+instance (GObject o, IsDescendantOf DBusInterfaceSkeleton o) => DBusInterfaceSkeletonK o++toDBusInterfaceSkeleton :: DBusInterfaceSkeletonK o => o -> IO DBusInterfaceSkeleton+toDBusInterfaceSkeleton = unsafeCastTo DBusInterfaceSkeleton++noDBusInterfaceSkeleton :: Maybe DBusInterfaceSkeleton+noDBusInterfaceSkeleton = Nothing++-- signal DBusInterfaceSkeleton::g-authorize-method+type DBusInterfaceSkeletonGAuthorizeMethodCallback =+    DBusMethodInvocation ->+    IO Bool++noDBusInterfaceSkeletonGAuthorizeMethodCallback :: Maybe DBusInterfaceSkeletonGAuthorizeMethodCallback+noDBusInterfaceSkeletonGAuthorizeMethodCallback = Nothing++type DBusInterfaceSkeletonGAuthorizeMethodCallbackC =+    Ptr () ->                               -- object+    Ptr DBusMethodInvocation ->+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkDBusInterfaceSkeletonGAuthorizeMethodCallback :: DBusInterfaceSkeletonGAuthorizeMethodCallbackC -> IO (FunPtr DBusInterfaceSkeletonGAuthorizeMethodCallbackC)++dBusInterfaceSkeletonGAuthorizeMethodClosure :: DBusInterfaceSkeletonGAuthorizeMethodCallback -> IO Closure+dBusInterfaceSkeletonGAuthorizeMethodClosure cb = newCClosure =<< mkDBusInterfaceSkeletonGAuthorizeMethodCallback wrapped+    where wrapped = dBusInterfaceSkeletonGAuthorizeMethodCallbackWrapper cb++dBusInterfaceSkeletonGAuthorizeMethodCallbackWrapper ::+    DBusInterfaceSkeletonGAuthorizeMethodCallback ->+    Ptr () ->+    Ptr DBusMethodInvocation ->+    Ptr () ->+    IO CInt+dBusInterfaceSkeletonGAuthorizeMethodCallbackWrapper _cb _ invocation _ = do+    invocation' <- (newObject DBusMethodInvocation) invocation+    result <- _cb  invocation'+    let result' = (fromIntegral . fromEnum) result+    return result'++onDBusInterfaceSkeletonGAuthorizeMethod :: (GObject a, MonadIO m) => a -> DBusInterfaceSkeletonGAuthorizeMethodCallback -> m SignalHandlerId+onDBusInterfaceSkeletonGAuthorizeMethod obj cb = liftIO $ connectDBusInterfaceSkeletonGAuthorizeMethod obj cb SignalConnectBefore+afterDBusInterfaceSkeletonGAuthorizeMethod :: (GObject a, MonadIO m) => a -> DBusInterfaceSkeletonGAuthorizeMethodCallback -> m SignalHandlerId+afterDBusInterfaceSkeletonGAuthorizeMethod obj cb = connectDBusInterfaceSkeletonGAuthorizeMethod obj cb SignalConnectAfter++connectDBusInterfaceSkeletonGAuthorizeMethod :: (GObject a, MonadIO m) =>+                                                a -> DBusInterfaceSkeletonGAuthorizeMethodCallback -> SignalConnectMode -> m SignalHandlerId+connectDBusInterfaceSkeletonGAuthorizeMethod obj cb after = liftIO $ do+    cb' <- mkDBusInterfaceSkeletonGAuthorizeMethodCallback (dBusInterfaceSkeletonGAuthorizeMethodCallbackWrapper cb)+    connectSignalFunPtr obj "g-authorize-method" cb' after++-- VVV Prop "g-flags"+   -- Type: TInterface "Gio" "DBusInterfaceSkeletonFlags"+   -- Flags: [PropertyReadable,PropertyWritable]++getDBusInterfaceSkeletonGFlags :: (MonadIO m, DBusInterfaceSkeletonK o) => o -> m [DBusInterfaceSkeletonFlags]+getDBusInterfaceSkeletonGFlags obj = liftIO $ getObjectPropertyFlags obj "g-flags"++setDBusInterfaceSkeletonGFlags :: (MonadIO m, DBusInterfaceSkeletonK o) => o -> [DBusInterfaceSkeletonFlags] -> m ()+setDBusInterfaceSkeletonGFlags obj val = liftIO $ setObjectPropertyFlags obj "g-flags" val++constructDBusInterfaceSkeletonGFlags :: [DBusInterfaceSkeletonFlags] -> IO ([Char], GValue)+constructDBusInterfaceSkeletonGFlags val = constructObjectPropertyFlags "g-flags" val++data DBusInterfaceSkeletonGFlagsPropertyInfo+instance AttrInfo DBusInterfaceSkeletonGFlagsPropertyInfo where+    type AttrAllowedOps DBusInterfaceSkeletonGFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DBusInterfaceSkeletonGFlagsPropertyInfo = (~) [DBusInterfaceSkeletonFlags]+    type AttrBaseTypeConstraint DBusInterfaceSkeletonGFlagsPropertyInfo = DBusInterfaceSkeletonK+    type AttrGetType DBusInterfaceSkeletonGFlagsPropertyInfo = [DBusInterfaceSkeletonFlags]+    type AttrLabel DBusInterfaceSkeletonGFlagsPropertyInfo = "DBusInterfaceSkeleton::g-flags"+    attrGet _ = getDBusInterfaceSkeletonGFlags+    attrSet _ = setDBusInterfaceSkeletonGFlags+    attrConstruct _ = constructDBusInterfaceSkeletonGFlags++type instance AttributeList DBusInterfaceSkeleton = DBusInterfaceSkeletonAttributeList+type DBusInterfaceSkeletonAttributeList = ('[ '("g-flags", DBusInterfaceSkeletonGFlagsPropertyInfo)] :: [(Symbol, *)])++data DBusInterfaceSkeletonGAuthorizeMethodSignalInfo+instance SignalInfo DBusInterfaceSkeletonGAuthorizeMethodSignalInfo where+    type HaskellCallbackType DBusInterfaceSkeletonGAuthorizeMethodSignalInfo = DBusInterfaceSkeletonGAuthorizeMethodCallback+    connectSignal _ = connectDBusInterfaceSkeletonGAuthorizeMethod++type instance SignalList DBusInterfaceSkeleton = DBusInterfaceSkeletonSignalList+type DBusInterfaceSkeletonSignalList = ('[ '("g-authorize-method", DBusInterfaceSkeletonGAuthorizeMethodSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method DBusInterfaceSkeleton::export+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "connection", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "connection", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_interface_skeleton_export" g_dbus_interface_skeleton_export :: +    Ptr DBusInterfaceSkeleton ->            -- _obj : TInterface "Gio" "DBusInterfaceSkeleton"+    Ptr DBusConnection ->                   -- connection : TInterface "Gio" "DBusConnection"+    CString ->                              -- object_path : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++dBusInterfaceSkeletonExport ::+    (MonadIO m, DBusInterfaceSkeletonK a, DBusConnectionK b) =>+    a ->                                    -- _obj+    b ->                                    -- connection+    T.Text ->                               -- object_path+    m ()+dBusInterfaceSkeletonExport _obj connection object_path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let connection' = unsafeManagedPtrCastPtr connection+    object_path' <- textToCString object_path+    onException (do+        _ <- propagateGError $ g_dbus_interface_skeleton_export _obj' connection' object_path'+        touchManagedPtr _obj+        touchManagedPtr connection+        freeMem object_path'+        return ()+     ) (do+        freeMem object_path'+     )++-- method DBusInterfaceSkeleton::flush+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_interface_skeleton_flush" g_dbus_interface_skeleton_flush :: +    Ptr DBusInterfaceSkeleton ->            -- _obj : TInterface "Gio" "DBusInterfaceSkeleton"+    IO ()+++dBusInterfaceSkeletonFlush ::+    (MonadIO m, DBusInterfaceSkeletonK a) =>+    a ->                                    -- _obj+    m ()+dBusInterfaceSkeletonFlush _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_dbus_interface_skeleton_flush _obj'+    touchManagedPtr _obj+    return ()++-- method DBusInterfaceSkeleton::get_connection+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusConnection"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_interface_skeleton_get_connection" g_dbus_interface_skeleton_get_connection :: +    Ptr DBusInterfaceSkeleton ->            -- _obj : TInterface "Gio" "DBusInterfaceSkeleton"+    IO (Ptr DBusConnection)+++dBusInterfaceSkeletonGetConnection ::+    (MonadIO m, DBusInterfaceSkeletonK a) =>+    a ->                                    -- _obj+    m DBusConnection+dBusInterfaceSkeletonGetConnection _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_interface_skeleton_get_connection _obj'+    checkUnexpectedReturnNULL "g_dbus_interface_skeleton_get_connection" result+    result' <- (newObject DBusConnection) result+    touchManagedPtr _obj+    return result'++-- method DBusInterfaceSkeleton::get_connections+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gio" "DBusConnection")+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_interface_skeleton_get_connections" g_dbus_interface_skeleton_get_connections :: +    Ptr DBusInterfaceSkeleton ->            -- _obj : TInterface "Gio" "DBusInterfaceSkeleton"+    IO (Ptr (GList (Ptr DBusConnection)))+++dBusInterfaceSkeletonGetConnections ::+    (MonadIO m, DBusInterfaceSkeletonK a) =>+    a ->                                    -- _obj+    m [DBusConnection]+dBusInterfaceSkeletonGetConnections _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_interface_skeleton_get_connections _obj'+    checkUnexpectedReturnNULL "g_dbus_interface_skeleton_get_connections" result+    result' <- unpackGList result+    result'' <- mapM (wrapObject DBusConnection) result'+    g_list_free result+    touchManagedPtr _obj+    return result''++-- method DBusInterfaceSkeleton::get_flags+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusInterfaceSkeletonFlags"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_interface_skeleton_get_flags" g_dbus_interface_skeleton_get_flags :: +    Ptr DBusInterfaceSkeleton ->            -- _obj : TInterface "Gio" "DBusInterfaceSkeleton"+    IO CUInt+++dBusInterfaceSkeletonGetFlags ::+    (MonadIO m, DBusInterfaceSkeletonK a) =>+    a ->                                    -- _obj+    m [DBusInterfaceSkeletonFlags]+dBusInterfaceSkeletonGetFlags _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_interface_skeleton_get_flags _obj'+    let result' = wordToGFlags result+    touchManagedPtr _obj+    return result'++-- method DBusInterfaceSkeleton::get_info+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusInterfaceInfo"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_interface_skeleton_get_info" g_dbus_interface_skeleton_get_info :: +    Ptr DBusInterfaceSkeleton ->            -- _obj : TInterface "Gio" "DBusInterfaceSkeleton"+    IO (Ptr DBusInterfaceInfo)+++dBusInterfaceSkeletonGetInfo ::+    (MonadIO m, DBusInterfaceSkeletonK a) =>+    a ->                                    -- _obj+    m DBusInterfaceInfo+dBusInterfaceSkeletonGetInfo _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_interface_skeleton_get_info _obj'+    checkUnexpectedReturnNULL "g_dbus_interface_skeleton_get_info" result+    result' <- (newBoxed DBusInterfaceInfo) result+    touchManagedPtr _obj+    return result'++-- method DBusInterfaceSkeleton::get_object_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_interface_skeleton_get_object_path" g_dbus_interface_skeleton_get_object_path :: +    Ptr DBusInterfaceSkeleton ->            -- _obj : TInterface "Gio" "DBusInterfaceSkeleton"+    IO CString+++dBusInterfaceSkeletonGetObjectPath ::+    (MonadIO m, DBusInterfaceSkeletonK a) =>+    a ->                                    -- _obj+    m T.Text+dBusInterfaceSkeletonGetObjectPath _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_interface_skeleton_get_object_path _obj'+    checkUnexpectedReturnNULL "g_dbus_interface_skeleton_get_object_path" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method DBusInterfaceSkeleton::get_properties+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TVariant+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_interface_skeleton_get_properties" g_dbus_interface_skeleton_get_properties :: +    Ptr DBusInterfaceSkeleton ->            -- _obj : TInterface "Gio" "DBusInterfaceSkeleton"+    IO (Ptr GVariant)+++dBusInterfaceSkeletonGetProperties ::+    (MonadIO m, DBusInterfaceSkeletonK a) =>+    a ->                                    -- _obj+    m GVariant+dBusInterfaceSkeletonGetProperties _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_interface_skeleton_get_properties _obj'+    checkUnexpectedReturnNULL "g_dbus_interface_skeleton_get_properties" result+    result' <- wrapGVariantPtr result+    touchManagedPtr _obj+    return result'++-- method DBusInterfaceSkeleton::has_connection+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "connection", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "connection", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_interface_skeleton_has_connection" g_dbus_interface_skeleton_has_connection :: +    Ptr DBusInterfaceSkeleton ->            -- _obj : TInterface "Gio" "DBusInterfaceSkeleton"+    Ptr DBusConnection ->                   -- connection : TInterface "Gio" "DBusConnection"+    IO CInt+++dBusInterfaceSkeletonHasConnection ::+    (MonadIO m, DBusInterfaceSkeletonK a, DBusConnectionK b) =>+    a ->                                    -- _obj+    b ->                                    -- connection+    m Bool+dBusInterfaceSkeletonHasConnection _obj connection = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let connection' = unsafeManagedPtrCastPtr connection+    result <- g_dbus_interface_skeleton_has_connection _obj' connection'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr connection+    return result'++-- method DBusInterfaceSkeleton::set_flags+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusInterfaceSkeletonFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusInterfaceSkeletonFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_interface_skeleton_set_flags" g_dbus_interface_skeleton_set_flags :: +    Ptr DBusInterfaceSkeleton ->            -- _obj : TInterface "Gio" "DBusInterfaceSkeleton"+    CUInt ->                                -- flags : TInterface "Gio" "DBusInterfaceSkeletonFlags"+    IO ()+++dBusInterfaceSkeletonSetFlags ::+    (MonadIO m, DBusInterfaceSkeletonK a) =>+    a ->                                    -- _obj+    [DBusInterfaceSkeletonFlags] ->         -- flags+    m ()+dBusInterfaceSkeletonSetFlags _obj flags = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    g_dbus_interface_skeleton_set_flags _obj' flags'+    touchManagedPtr _obj+    return ()++-- method DBusInterfaceSkeleton::unexport+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_interface_skeleton_unexport" g_dbus_interface_skeleton_unexport :: +    Ptr DBusInterfaceSkeleton ->            -- _obj : TInterface "Gio" "DBusInterfaceSkeleton"+    IO ()+++dBusInterfaceSkeletonUnexport ::+    (MonadIO m, DBusInterfaceSkeletonK a) =>+    a ->                                    -- _obj+    m ()+dBusInterfaceSkeletonUnexport _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_dbus_interface_skeleton_unexport _obj'+    touchManagedPtr _obj+    return ()++-- method DBusInterfaceSkeleton::unexport_from_connection+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "connection", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "connection", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_interface_skeleton_unexport_from_connection" g_dbus_interface_skeleton_unexport_from_connection :: +    Ptr DBusInterfaceSkeleton ->            -- _obj : TInterface "Gio" "DBusInterfaceSkeleton"+    Ptr DBusConnection ->                   -- connection : TInterface "Gio" "DBusConnection"+    IO ()+++dBusInterfaceSkeletonUnexportFromConnection ::+    (MonadIO m, DBusInterfaceSkeletonK a, DBusConnectionK b) =>+    a ->                                    -- _obj+    b ->                                    -- connection+    m ()+dBusInterfaceSkeletonUnexportFromConnection _obj connection = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let connection' = unsafeManagedPtrCastPtr connection+    g_dbus_interface_skeleton_unexport_from_connection _obj' connection'+    touchManagedPtr _obj+    touchManagedPtr connection+    return ()++
+ GI/Gio/Objects/DBusInterfaceSkeleton.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gio.Objects.DBusInterfaceSkeleton where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype DBusInterfaceSkeleton = DBusInterfaceSkeleton (ForeignPtr DBusInterfaceSkeleton)+instance GObject DBusInterfaceSkeleton where+class GObject o => DBusInterfaceSkeletonK o+instance (GObject o, IsDescendantOf DBusInterfaceSkeleton o) => DBusInterfaceSkeletonK o+data DBusInterfaceSkeletonGFlagsPropertyInfo+data DBusInterfaceSkeletonGAuthorizeMethodSignalInfo
+ GI/Gio/Objects/DBusMenuModel.hs view
@@ -0,0 +1,99 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.DBusMenuModel+    ( ++-- * Exported types+    DBusMenuModel(..)                       ,+    DBusMenuModelK                          ,+    toDBusMenuModel                         ,+    noDBusMenuModel                         ,+++ -- * Methods+-- ** dBusMenuModelGet+    dBusMenuModelGet                        ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype DBusMenuModel = DBusMenuModel (ForeignPtr DBusMenuModel)+foreign import ccall "g_dbus_menu_model_get_type"+    c_g_dbus_menu_model_get_type :: IO GType++type instance ParentTypes DBusMenuModel = DBusMenuModelParentTypes+type DBusMenuModelParentTypes = '[MenuModel, GObject.Object]++instance GObject DBusMenuModel where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_dbus_menu_model_get_type+    ++class GObject o => DBusMenuModelK o+instance (GObject o, IsDescendantOf DBusMenuModel o) => DBusMenuModelK o++toDBusMenuModel :: DBusMenuModelK o => o -> IO DBusMenuModel+toDBusMenuModel = unsafeCastTo DBusMenuModel++noDBusMenuModel :: Maybe DBusMenuModel+noDBusMenuModel = Nothing++type instance AttributeList DBusMenuModel = DBusMenuModelAttributeList+type DBusMenuModelAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList DBusMenuModel = DBusMenuModelSignalList+type DBusMenuModelSignalList = ('[ '("items-changed", MenuModelItemsChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method DBusMenuModel::get+-- method type : MemberFunction+-- Args : [Arg {argName = "connection", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "bus_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "connection", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "bus_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusMenuModel"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_menu_model_get" g_dbus_menu_model_get :: +    Ptr DBusConnection ->                   -- connection : TInterface "Gio" "DBusConnection"+    CString ->                              -- bus_name : TBasicType TUTF8+    CString ->                              -- object_path : TBasicType TUTF8+    IO (Ptr DBusMenuModel)+++dBusMenuModelGet ::+    (MonadIO m, DBusConnectionK a) =>+    a ->                                    -- connection+    T.Text ->                               -- bus_name+    T.Text ->                               -- object_path+    m DBusMenuModel+dBusMenuModelGet connection bus_name object_path = liftIO $ do+    let connection' = unsafeManagedPtrCastPtr connection+    bus_name' <- textToCString bus_name+    object_path' <- textToCString object_path+    result <- g_dbus_menu_model_get connection' bus_name' object_path'+    checkUnexpectedReturnNULL "g_dbus_menu_model_get" result+    result' <- (wrapObject DBusMenuModel) result+    touchManagedPtr connection+    freeMem bus_name'+    freeMem object_path'+    return result'++
+ GI/Gio/Objects/DBusMenuModel.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Objects.DBusMenuModel where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype DBusMenuModel = DBusMenuModel (ForeignPtr DBusMenuModel)+instance GObject DBusMenuModel where+class GObject o => DBusMenuModelK o+instance (GObject o, IsDescendantOf DBusMenuModel o) => DBusMenuModelK o
+ GI/Gio/Objects/DBusMessage.hs view
@@ -0,0 +1,1591 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.DBusMessage+    ( ++-- * Exported types+    DBusMessage(..)                         ,+    DBusMessageK                            ,+    toDBusMessage                           ,+    noDBusMessage                           ,+++ -- * Methods+-- ** dBusMessageBytesNeeded+    dBusMessageBytesNeeded                  ,+++-- ** dBusMessageCopy+    dBusMessageCopy                         ,+++-- ** dBusMessageGetArg0+    dBusMessageGetArg0                      ,+++-- ** dBusMessageGetBody+    dBusMessageGetBody                      ,+++-- ** dBusMessageGetByteOrder+    dBusMessageGetByteOrder                 ,+++-- ** dBusMessageGetDestination+    dBusMessageGetDestination               ,+++-- ** dBusMessageGetErrorName+    dBusMessageGetErrorName                 ,+++-- ** dBusMessageGetFlags+    dBusMessageGetFlags                     ,+++-- ** dBusMessageGetHeader+    dBusMessageGetHeader                    ,+++-- ** dBusMessageGetHeaderFields+    dBusMessageGetHeaderFields              ,+++-- ** dBusMessageGetInterface+    dBusMessageGetInterface                 ,+++-- ** dBusMessageGetLocked+    dBusMessageGetLocked                    ,+++-- ** dBusMessageGetMember+    dBusMessageGetMember                    ,+++-- ** dBusMessageGetMessageType+    dBusMessageGetMessageType               ,+++-- ** dBusMessageGetNumUnixFds+    dBusMessageGetNumUnixFds                ,+++-- ** dBusMessageGetPath+    dBusMessageGetPath                      ,+++-- ** dBusMessageGetReplySerial+    dBusMessageGetReplySerial               ,+++-- ** dBusMessageGetSender+    dBusMessageGetSender                    ,+++-- ** dBusMessageGetSerial+    dBusMessageGetSerial                    ,+++-- ** dBusMessageGetSignature+    dBusMessageGetSignature                 ,+++-- ** dBusMessageGetUnixFdList+    dBusMessageGetUnixFdList                ,+++-- ** dBusMessageLock+    dBusMessageLock                         ,+++-- ** dBusMessageNew+    dBusMessageNew                          ,+++-- ** dBusMessageNewFromBlob+    dBusMessageNewFromBlob                  ,+++-- ** dBusMessageNewMethodCall+    dBusMessageNewMethodCall                ,+++-- ** dBusMessageNewMethodErrorLiteral+    dBusMessageNewMethodErrorLiteral        ,+++-- ** dBusMessageNewMethodReply+    dBusMessageNewMethodReply               ,+++-- ** dBusMessageNewSignal+    dBusMessageNewSignal                    ,+++-- ** dBusMessagePrint+    dBusMessagePrint                        ,+++-- ** dBusMessageSetBody+    dBusMessageSetBody                      ,+++-- ** dBusMessageSetByteOrder+    dBusMessageSetByteOrder                 ,+++-- ** dBusMessageSetDestination+    dBusMessageSetDestination               ,+++-- ** dBusMessageSetErrorName+    dBusMessageSetErrorName                 ,+++-- ** dBusMessageSetFlags+    dBusMessageSetFlags                     ,+++-- ** dBusMessageSetHeader+    dBusMessageSetHeader                    ,+++-- ** dBusMessageSetInterface+    dBusMessageSetInterface                 ,+++-- ** dBusMessageSetMember+    dBusMessageSetMember                    ,+++-- ** dBusMessageSetMessageType+    dBusMessageSetMessageType               ,+++-- ** dBusMessageSetNumUnixFds+    dBusMessageSetNumUnixFds                ,+++-- ** dBusMessageSetPath+    dBusMessageSetPath                      ,+++-- ** dBusMessageSetReplySerial+    dBusMessageSetReplySerial               ,+++-- ** dBusMessageSetSender+    dBusMessageSetSender                    ,+++-- ** dBusMessageSetSerial+    dBusMessageSetSerial                    ,+++-- ** dBusMessageSetSignature+    dBusMessageSetSignature                 ,+++-- ** dBusMessageSetUnixFdList+    dBusMessageSetUnixFdList                ,+++-- ** dBusMessageToBlob+    dBusMessageToBlob                       ,+++-- ** dBusMessageToGerror+    dBusMessageToGerror                     ,+++++ -- * Properties+-- ** Locked+    DBusMessageLockedPropertyInfo           ,+    getDBusMessageLocked                    ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype DBusMessage = DBusMessage (ForeignPtr DBusMessage)+foreign import ccall "g_dbus_message_get_type"+    c_g_dbus_message_get_type :: IO GType++type instance ParentTypes DBusMessage = DBusMessageParentTypes+type DBusMessageParentTypes = '[GObject.Object]++instance GObject DBusMessage where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_dbus_message_get_type+    ++class GObject o => DBusMessageK o+instance (GObject o, IsDescendantOf DBusMessage o) => DBusMessageK o++toDBusMessage :: DBusMessageK o => o -> IO DBusMessage+toDBusMessage = unsafeCastTo DBusMessage++noDBusMessage :: Maybe DBusMessage+noDBusMessage = Nothing++-- VVV Prop "locked"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getDBusMessageLocked :: (MonadIO m, DBusMessageK o) => o -> m Bool+getDBusMessageLocked obj = liftIO $ getObjectPropertyBool obj "locked"++data DBusMessageLockedPropertyInfo+instance AttrInfo DBusMessageLockedPropertyInfo where+    type AttrAllowedOps DBusMessageLockedPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint DBusMessageLockedPropertyInfo = (~) ()+    type AttrBaseTypeConstraint DBusMessageLockedPropertyInfo = DBusMessageK+    type AttrGetType DBusMessageLockedPropertyInfo = Bool+    type AttrLabel DBusMessageLockedPropertyInfo = "DBusMessage::locked"+    attrGet _ = getDBusMessageLocked+    attrSet _ = undefined+    attrConstruct _ = undefined++type instance AttributeList DBusMessage = DBusMessageAttributeList+type DBusMessageAttributeList = ('[ '("locked", DBusMessageLockedPropertyInfo)] :: [(Symbol, *)])++type instance SignalList DBusMessage = DBusMessageSignalList+type DBusMessageSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method DBusMessage::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gio" "DBusMessage"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_new" g_dbus_message_new :: +    IO (Ptr DBusMessage)+++dBusMessageNew ::+    (MonadIO m) =>+    m DBusMessage+dBusMessageNew  = liftIO $ do+    result <- g_dbus_message_new+    checkUnexpectedReturnNULL "g_dbus_message_new" result+    result' <- (wrapObject DBusMessage) result+    return result'++-- method DBusMessage::new_from_blob+-- method type : Constructor+-- Args : [Arg {argName = "blob", argType = TCArray False (-1) 1 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "blob_len", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "capabilities", argType = TInterface "Gio" "DBusCapabilityFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "blob_len", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "blob", argType = TCArray False (-1) 1 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "capabilities", argType = TInterface "Gio" "DBusCapabilityFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusMessage"+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_message_new_from_blob" g_dbus_message_new_from_blob :: +    Ptr Word8 ->                            -- blob : TCArray False (-1) 1 (TBasicType TUInt8)+    Word64 ->                               -- blob_len : TBasicType TUInt64+    CUInt ->                                -- capabilities : TInterface "Gio" "DBusCapabilityFlags"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr DBusMessage)+++dBusMessageNewFromBlob ::+    (MonadIO m) =>+    ByteString ->                           -- blob+    [DBusCapabilityFlags] ->                -- capabilities+    m DBusMessage+dBusMessageNewFromBlob blob capabilities = liftIO $ do+    let blob_len = fromIntegral $ B.length blob+    blob' <- packByteString blob+    let capabilities' = gflagsToWord capabilities+    onException (do+        result <- propagateGError $ g_dbus_message_new_from_blob blob' blob_len capabilities'+        checkUnexpectedReturnNULL "g_dbus_message_new_from_blob" result+        result' <- (wrapObject DBusMessage) result+        freeMem blob'+        return result'+     ) (do+        freeMem blob'+     )++-- method DBusMessage::new_method_call+-- method type : Constructor+-- Args : [Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "method", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "method", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusMessage"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_new_method_call" g_dbus_message_new_method_call :: +    CString ->                              -- name : TBasicType TUTF8+    CString ->                              -- path : TBasicType TUTF8+    CString ->                              -- interface_ : TBasicType TUTF8+    CString ->                              -- method : TBasicType TUTF8+    IO (Ptr DBusMessage)+++dBusMessageNewMethodCall ::+    (MonadIO m) =>+    Maybe (T.Text) ->                       -- name+    T.Text ->                               -- path+    Maybe (T.Text) ->                       -- interface_+    T.Text ->                               -- method+    m DBusMessage+dBusMessageNewMethodCall name path interface_ method = liftIO $ do+    maybeName <- case name of+        Nothing -> return nullPtr+        Just jName -> do+            jName' <- textToCString jName+            return jName'+    path' <- textToCString path+    maybeInterface_ <- case interface_ of+        Nothing -> return nullPtr+        Just jInterface_ -> do+            jInterface_' <- textToCString jInterface_+            return jInterface_'+    method' <- textToCString method+    result <- g_dbus_message_new_method_call maybeName path' maybeInterface_ method'+    checkUnexpectedReturnNULL "g_dbus_message_new_method_call" result+    result' <- (wrapObject DBusMessage) result+    freeMem maybeName+    freeMem path'+    freeMem maybeInterface_+    freeMem method'+    return result'++-- method DBusMessage::new_signal+-- method type : Constructor+-- Args : [Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "signal", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "signal", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusMessage"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_new_signal" g_dbus_message_new_signal :: +    CString ->                              -- path : TBasicType TUTF8+    CString ->                              -- interface_ : TBasicType TUTF8+    CString ->                              -- signal : TBasicType TUTF8+    IO (Ptr DBusMessage)+++dBusMessageNewSignal ::+    (MonadIO m) =>+    T.Text ->                               -- path+    T.Text ->                               -- interface_+    T.Text ->                               -- signal+    m DBusMessage+dBusMessageNewSignal path interface_ signal = liftIO $ do+    path' <- textToCString path+    interface_' <- textToCString interface_+    signal' <- textToCString signal+    result <- g_dbus_message_new_signal path' interface_' signal'+    checkUnexpectedReturnNULL "g_dbus_message_new_signal" result+    result' <- (wrapObject DBusMessage) result+    freeMem path'+    freeMem interface_'+    freeMem signal'+    return result'++-- method DBusMessage::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusMessage"+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_message_copy" g_dbus_message_copy :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr DBusMessage)+++dBusMessageCopy ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    m DBusMessage+dBusMessageCopy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    onException (do+        result <- propagateGError $ g_dbus_message_copy _obj'+        checkUnexpectedReturnNULL "g_dbus_message_copy" result+        result' <- (wrapObject DBusMessage) result+        touchManagedPtr _obj+        return result'+     ) (do+        return ()+     )++-- method DBusMessage::get_arg0+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_get_arg0" g_dbus_message_get_arg0 :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    IO CString+++dBusMessageGetArg0 ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    m T.Text+dBusMessageGetArg0 _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_message_get_arg0 _obj'+    checkUnexpectedReturnNULL "g_dbus_message_get_arg0" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method DBusMessage::get_body+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TVariant+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_get_body" g_dbus_message_get_body :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    IO (Ptr GVariant)+++dBusMessageGetBody ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    m GVariant+dBusMessageGetBody _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_message_get_body _obj'+    checkUnexpectedReturnNULL "g_dbus_message_get_body" result+    result' <- newGVariantFromPtr result+    touchManagedPtr _obj+    return result'++-- method DBusMessage::get_byte_order+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusMessageByteOrder"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_get_byte_order" g_dbus_message_get_byte_order :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    IO CUInt+++dBusMessageGetByteOrder ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    m DBusMessageByteOrder+dBusMessageGetByteOrder _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_message_get_byte_order _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method DBusMessage::get_destination+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_get_destination" g_dbus_message_get_destination :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    IO CString+++dBusMessageGetDestination ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    m T.Text+dBusMessageGetDestination _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_message_get_destination _obj'+    checkUnexpectedReturnNULL "g_dbus_message_get_destination" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method DBusMessage::get_error_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_get_error_name" g_dbus_message_get_error_name :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    IO CString+++dBusMessageGetErrorName ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    m T.Text+dBusMessageGetErrorName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_message_get_error_name _obj'+    checkUnexpectedReturnNULL "g_dbus_message_get_error_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method DBusMessage::get_flags+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusMessageFlags"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_get_flags" g_dbus_message_get_flags :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    IO CUInt+++dBusMessageGetFlags ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    m [DBusMessageFlags]+dBusMessageGetFlags _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_message_get_flags _obj'+    let result' = wordToGFlags result+    touchManagedPtr _obj+    return result'++-- method DBusMessage::get_header+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "header_field", argType = TInterface "Gio" "DBusMessageHeaderField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "header_field", argType = TInterface "Gio" "DBusMessageHeaderField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TVariant+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_get_header" g_dbus_message_get_header :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    CUInt ->                                -- header_field : TInterface "Gio" "DBusMessageHeaderField"+    IO (Ptr GVariant)+++dBusMessageGetHeader ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    DBusMessageHeaderField ->               -- header_field+    m GVariant+dBusMessageGetHeader _obj header_field = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let header_field' = (fromIntegral . fromEnum) header_field+    result <- g_dbus_message_get_header _obj' header_field'+    checkUnexpectedReturnNULL "g_dbus_message_get_header" result+    result' <- wrapGVariantPtr result+    touchManagedPtr _obj+    return result'++-- method DBusMessage::get_header_fields+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray True (-1) (-1) (TBasicType TUInt8)+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_get_header_fields" g_dbus_message_get_header_fields :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    IO (Ptr Word8)+++dBusMessageGetHeaderFields ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    m ByteString+dBusMessageGetHeaderFields _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_message_get_header_fields _obj'+    checkUnexpectedReturnNULL "g_dbus_message_get_header_fields" result+    result' <- unpackZeroTerminatedByteString result+    touchManagedPtr _obj+    return result'++-- method DBusMessage::get_interface+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_get_interface" g_dbus_message_get_interface :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    IO CString+++dBusMessageGetInterface ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    m T.Text+dBusMessageGetInterface _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_message_get_interface _obj'+    checkUnexpectedReturnNULL "g_dbus_message_get_interface" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method DBusMessage::get_locked+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_get_locked" g_dbus_message_get_locked :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    IO CInt+++dBusMessageGetLocked ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    m Bool+dBusMessageGetLocked _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_message_get_locked _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method DBusMessage::get_member+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_get_member" g_dbus_message_get_member :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    IO CString+++dBusMessageGetMember ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    m T.Text+dBusMessageGetMember _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_message_get_member _obj'+    checkUnexpectedReturnNULL "g_dbus_message_get_member" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method DBusMessage::get_message_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusMessageType"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_get_message_type" g_dbus_message_get_message_type :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    IO CUInt+++dBusMessageGetMessageType ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    m DBusMessageType+dBusMessageGetMessageType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_message_get_message_type _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method DBusMessage::get_num_unix_fds+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_get_num_unix_fds" g_dbus_message_get_num_unix_fds :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    IO Word32+++dBusMessageGetNumUnixFds ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    m Word32+dBusMessageGetNumUnixFds _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_message_get_num_unix_fds _obj'+    touchManagedPtr _obj+    return result++-- method DBusMessage::get_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_get_path" g_dbus_message_get_path :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    IO CString+++dBusMessageGetPath ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    m T.Text+dBusMessageGetPath _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_message_get_path _obj'+    checkUnexpectedReturnNULL "g_dbus_message_get_path" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method DBusMessage::get_reply_serial+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_get_reply_serial" g_dbus_message_get_reply_serial :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    IO Word32+++dBusMessageGetReplySerial ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    m Word32+dBusMessageGetReplySerial _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_message_get_reply_serial _obj'+    touchManagedPtr _obj+    return result++-- method DBusMessage::get_sender+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_get_sender" g_dbus_message_get_sender :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    IO CString+++dBusMessageGetSender ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    m T.Text+dBusMessageGetSender _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_message_get_sender _obj'+    checkUnexpectedReturnNULL "g_dbus_message_get_sender" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method DBusMessage::get_serial+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_get_serial" g_dbus_message_get_serial :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    IO Word32+++dBusMessageGetSerial ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    m Word32+dBusMessageGetSerial _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_message_get_serial _obj'+    touchManagedPtr _obj+    return result++-- method DBusMessage::get_signature+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_get_signature" g_dbus_message_get_signature :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    IO CString+++dBusMessageGetSignature ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    m T.Text+dBusMessageGetSignature _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_message_get_signature _obj'+    checkUnexpectedReturnNULL "g_dbus_message_get_signature" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method DBusMessage::get_unix_fd_list+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "UnixFDList"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_get_unix_fd_list" g_dbus_message_get_unix_fd_list :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    IO (Ptr UnixFDList)+++dBusMessageGetUnixFdList ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    m UnixFDList+dBusMessageGetUnixFdList _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_message_get_unix_fd_list _obj'+    checkUnexpectedReturnNULL "g_dbus_message_get_unix_fd_list" result+    result' <- (newObject UnixFDList) result+    touchManagedPtr _obj+    return result'++-- method DBusMessage::lock+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_lock" g_dbus_message_lock :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    IO ()+++dBusMessageLock ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    m ()+dBusMessageLock _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_dbus_message_lock _obj'+    touchManagedPtr _obj+    return ()++-- method DBusMessage::new_method_error_literal+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "error_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "error_message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "error_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "error_message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusMessage"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_new_method_error_literal" g_dbus_message_new_method_error_literal :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    CString ->                              -- error_name : TBasicType TUTF8+    CString ->                              -- error_message : TBasicType TUTF8+    IO (Ptr DBusMessage)+++dBusMessageNewMethodErrorLiteral ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- error_name+    T.Text ->                               -- error_message+    m DBusMessage+dBusMessageNewMethodErrorLiteral _obj error_name error_message = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    error_name' <- textToCString error_name+    error_message' <- textToCString error_message+    result <- g_dbus_message_new_method_error_literal _obj' error_name' error_message'+    checkUnexpectedReturnNULL "g_dbus_message_new_method_error_literal" result+    result' <- (wrapObject DBusMessage) result+    touchManagedPtr _obj+    freeMem error_name'+    freeMem error_message'+    return result'++-- method DBusMessage::new_method_reply+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusMessage"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_new_method_reply" g_dbus_message_new_method_reply :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    IO (Ptr DBusMessage)+++dBusMessageNewMethodReply ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    m DBusMessage+dBusMessageNewMethodReply _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_message_new_method_reply _obj'+    checkUnexpectedReturnNULL "g_dbus_message_new_method_reply" result+    result' <- (wrapObject DBusMessage) result+    touchManagedPtr _obj+    return result'++-- method DBusMessage::print+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "indent", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "indent", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_print" g_dbus_message_print :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    Word32 ->                               -- indent : TBasicType TUInt32+    IO CString+++dBusMessagePrint ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- indent+    m T.Text+dBusMessagePrint _obj indent = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_message_print _obj' indent+    checkUnexpectedReturnNULL "g_dbus_message_print" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method DBusMessage::set_body+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "body", argType = TVariant, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "body", argType = TVariant, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_set_body" g_dbus_message_set_body :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    Ptr GVariant ->                         -- body : TVariant+    IO ()+++dBusMessageSetBody ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    GVariant ->                             -- body+    m ()+dBusMessageSetBody _obj body = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let body' = unsafeManagedPtrGetPtr body+    g_dbus_message_set_body _obj' body'+    touchManagedPtr _obj+    return ()++-- method DBusMessage::set_byte_order+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "byte_order", argType = TInterface "Gio" "DBusMessageByteOrder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "byte_order", argType = TInterface "Gio" "DBusMessageByteOrder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_set_byte_order" g_dbus_message_set_byte_order :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    CUInt ->                                -- byte_order : TInterface "Gio" "DBusMessageByteOrder"+    IO ()+++dBusMessageSetByteOrder ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    DBusMessageByteOrder ->                 -- byte_order+    m ()+dBusMessageSetByteOrder _obj byte_order = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let byte_order' = (fromIntegral . fromEnum) byte_order+    g_dbus_message_set_byte_order _obj' byte_order'+    touchManagedPtr _obj+    return ()++-- method DBusMessage::set_destination+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_set_destination" g_dbus_message_set_destination :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    CString ->                              -- value : TBasicType TUTF8+    IO ()+++dBusMessageSetDestination ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- value+    m ()+dBusMessageSetDestination _obj value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    value' <- textToCString value+    g_dbus_message_set_destination _obj' value'+    touchManagedPtr _obj+    freeMem value'+    return ()++-- method DBusMessage::set_error_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_set_error_name" g_dbus_message_set_error_name :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    CString ->                              -- value : TBasicType TUTF8+    IO ()+++dBusMessageSetErrorName ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- value+    m ()+dBusMessageSetErrorName _obj value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    value' <- textToCString value+    g_dbus_message_set_error_name _obj' value'+    touchManagedPtr _obj+    freeMem value'+    return ()++-- method DBusMessage::set_flags+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusMessageFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusMessageFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_set_flags" g_dbus_message_set_flags :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    CUInt ->                                -- flags : TInterface "Gio" "DBusMessageFlags"+    IO ()+++dBusMessageSetFlags ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    [DBusMessageFlags] ->                   -- flags+    m ()+dBusMessageSetFlags _obj flags = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    g_dbus_message_set_flags _obj' flags'+    touchManagedPtr _obj+    return ()++-- method DBusMessage::set_header+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "header_field", argType = TInterface "Gio" "DBusMessageHeaderField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "header_field", argType = TInterface "Gio" "DBusMessageHeaderField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_set_header" g_dbus_message_set_header :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    CUInt ->                                -- header_field : TInterface "Gio" "DBusMessageHeaderField"+    Ptr GVariant ->                         -- value : TVariant+    IO ()+++dBusMessageSetHeader ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    DBusMessageHeaderField ->               -- header_field+    Maybe (GVariant) ->                     -- value+    m ()+dBusMessageSetHeader _obj header_field value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let header_field' = (fromIntegral . fromEnum) header_field+    maybeValue <- case value of+        Nothing -> return nullPtr+        Just jValue -> do+            let jValue' = unsafeManagedPtrGetPtr jValue+            return jValue'+    g_dbus_message_set_header _obj' header_field' maybeValue+    touchManagedPtr _obj+    return ()++-- method DBusMessage::set_interface+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_set_interface" g_dbus_message_set_interface :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    CString ->                              -- value : TBasicType TUTF8+    IO ()+++dBusMessageSetInterface ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- value+    m ()+dBusMessageSetInterface _obj value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    value' <- textToCString value+    g_dbus_message_set_interface _obj' value'+    touchManagedPtr _obj+    freeMem value'+    return ()++-- method DBusMessage::set_member+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_set_member" g_dbus_message_set_member :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    CString ->                              -- value : TBasicType TUTF8+    IO ()+++dBusMessageSetMember ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- value+    m ()+dBusMessageSetMember _obj value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    value' <- textToCString value+    g_dbus_message_set_member _obj' value'+    touchManagedPtr _obj+    freeMem value'+    return ()++-- method DBusMessage::set_message_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "Gio" "DBusMessageType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "Gio" "DBusMessageType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_set_message_type" g_dbus_message_set_message_type :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    CUInt ->                                -- type : TInterface "Gio" "DBusMessageType"+    IO ()+++dBusMessageSetMessageType ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    DBusMessageType ->                      -- type+    m ()+dBusMessageSetMessageType _obj type_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let type_' = (fromIntegral . fromEnum) type_+    g_dbus_message_set_message_type _obj' type_'+    touchManagedPtr _obj+    return ()++-- method DBusMessage::set_num_unix_fds+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_set_num_unix_fds" g_dbus_message_set_num_unix_fds :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    Word32 ->                               -- value : TBasicType TUInt32+    IO ()+++dBusMessageSetNumUnixFds ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- value+    m ()+dBusMessageSetNumUnixFds _obj value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_dbus_message_set_num_unix_fds _obj' value+    touchManagedPtr _obj+    return ()++-- method DBusMessage::set_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_set_path" g_dbus_message_set_path :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    CString ->                              -- value : TBasicType TUTF8+    IO ()+++dBusMessageSetPath ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- value+    m ()+dBusMessageSetPath _obj value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    value' <- textToCString value+    g_dbus_message_set_path _obj' value'+    touchManagedPtr _obj+    freeMem value'+    return ()++-- method DBusMessage::set_reply_serial+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_set_reply_serial" g_dbus_message_set_reply_serial :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    Word32 ->                               -- value : TBasicType TUInt32+    IO ()+++dBusMessageSetReplySerial ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- value+    m ()+dBusMessageSetReplySerial _obj value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_dbus_message_set_reply_serial _obj' value+    touchManagedPtr _obj+    return ()++-- method DBusMessage::set_sender+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_set_sender" g_dbus_message_set_sender :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    CString ->                              -- value : TBasicType TUTF8+    IO ()+++dBusMessageSetSender ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- value+    m ()+dBusMessageSetSender _obj value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    value' <- textToCString value+    g_dbus_message_set_sender _obj' value'+    touchManagedPtr _obj+    freeMem value'+    return ()++-- method DBusMessage::set_serial+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "serial", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "serial", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_set_serial" g_dbus_message_set_serial :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    Word32 ->                               -- serial : TBasicType TUInt32+    IO ()+++dBusMessageSetSerial ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- serial+    m ()+dBusMessageSetSerial _obj serial = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_dbus_message_set_serial _obj' serial+    touchManagedPtr _obj+    return ()++-- method DBusMessage::set_signature+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_set_signature" g_dbus_message_set_signature :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    CString ->                              -- value : TBasicType TUTF8+    IO ()+++dBusMessageSetSignature ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- value+    m ()+dBusMessageSetSignature _obj value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    value' <- textToCString value+    g_dbus_message_set_signature _obj' value'+    touchManagedPtr _obj+    freeMem value'+    return ()++-- method DBusMessage::set_unix_fd_list+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fd_list", argType = TInterface "Gio" "UnixFDList", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fd_list", argType = TInterface "Gio" "UnixFDList", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_message_set_unix_fd_list" g_dbus_message_set_unix_fd_list :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    Ptr UnixFDList ->                       -- fd_list : TInterface "Gio" "UnixFDList"+    IO ()+++dBusMessageSetUnixFdList ::+    (MonadIO m, DBusMessageK a, UnixFDListK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- fd_list+    m ()+dBusMessageSetUnixFdList _obj fd_list = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeFd_list <- case fd_list of+        Nothing -> return nullPtr+        Just jFd_list -> do+            let jFd_list' = unsafeManagedPtrCastPtr jFd_list+            return jFd_list'+    g_dbus_message_set_unix_fd_list _obj' maybeFd_list+    touchManagedPtr _obj+    whenJust fd_list touchManagedPtr+    return ()++-- method DBusMessage::to_blob+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "out_size", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "capabilities", argType = TInterface "Gio" "DBusCapabilityFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "out_size", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "capabilities", argType = TInterface "Gio" "DBusCapabilityFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray False (-1) 1 (TBasicType TUInt8)+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_message_to_blob" g_dbus_message_to_blob :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    Ptr Word64 ->                           -- out_size : TBasicType TUInt64+    CUInt ->                                -- capabilities : TInterface "Gio" "DBusCapabilityFlags"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Word8)+++dBusMessageToBlob ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    [DBusCapabilityFlags] ->                -- capabilities+    m ByteString+dBusMessageToBlob _obj capabilities = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    out_size <- allocMem :: IO (Ptr Word64)+    let capabilities' = gflagsToWord capabilities+    onException (do+        result <- propagateGError $ g_dbus_message_to_blob _obj' out_size capabilities'+        out_size' <- peek out_size+        checkUnexpectedReturnNULL "g_dbus_message_to_blob" result+        result' <- (unpackByteStringWithLength out_size') result+        freeMem result+        touchManagedPtr _obj+        freeMem out_size+        return result'+     ) (do+        freeMem out_size+     )++-- method DBusMessage::to_gerror+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_message_to_gerror" g_dbus_message_to_gerror :: +    Ptr DBusMessage ->                      -- _obj : TInterface "Gio" "DBusMessage"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++dBusMessageToGerror ::+    (MonadIO m, DBusMessageK a) =>+    a ->                                    -- _obj+    m ()+dBusMessageToGerror _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    onException (do+        _ <- propagateGError $ g_dbus_message_to_gerror _obj'+        touchManagedPtr _obj+        return ()+     ) (do+        return ()+     )++-- method DBusMessage::bytes_needed+-- method type : MemberFunction+-- Args : [Arg {argName = "blob", argType = TCArray False (-1) 1 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "blob_len", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "blob_len", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "blob", argType = TCArray False (-1) 1 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_message_bytes_needed" g_dbus_message_bytes_needed :: +    Ptr Word8 ->                            -- blob : TCArray False (-1) 1 (TBasicType TUInt8)+    Word64 ->                               -- blob_len : TBasicType TUInt64+    Ptr (Ptr GError) ->                     -- error+    IO Int64+++dBusMessageBytesNeeded ::+    (MonadIO m) =>+    ByteString ->                           -- blob+    m Int64+dBusMessageBytesNeeded blob = liftIO $ do+    let blob_len = fromIntegral $ B.length blob+    blob' <- packByteString blob+    onException (do+        result <- propagateGError $ g_dbus_message_bytes_needed blob' blob_len+        freeMem blob'+        return result+     ) (do+        freeMem blob'+     )++
+ GI/Gio/Objects/DBusMessage.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gio.Objects.DBusMessage where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype DBusMessage = DBusMessage (ForeignPtr DBusMessage)+instance GObject DBusMessage where+class GObject o => DBusMessageK o+instance (GObject o, IsDescendantOf DBusMessage o) => DBusMessageK o+data DBusMessageLockedPropertyInfo
+ GI/Gio/Objects/DBusMethodInvocation.hs view
@@ -0,0 +1,513 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.DBusMethodInvocation+    ( ++-- * Exported types+    DBusMethodInvocation(..)                ,+    DBusMethodInvocationK                   ,+    toDBusMethodInvocation                  ,+    noDBusMethodInvocation                  ,+++ -- * Methods+-- ** dBusMethodInvocationGetConnection+    dBusMethodInvocationGetConnection       ,+++-- ** dBusMethodInvocationGetInterfaceName+    dBusMethodInvocationGetInterfaceName    ,+++-- ** dBusMethodInvocationGetMessage+    dBusMethodInvocationGetMessage          ,+++-- ** dBusMethodInvocationGetMethodInfo+    dBusMethodInvocationGetMethodInfo       ,+++-- ** dBusMethodInvocationGetMethodName+    dBusMethodInvocationGetMethodName       ,+++-- ** dBusMethodInvocationGetObjectPath+    dBusMethodInvocationGetObjectPath       ,+++-- ** dBusMethodInvocationGetParameters+    dBusMethodInvocationGetParameters       ,+++-- ** dBusMethodInvocationGetPropertyInfo+    dBusMethodInvocationGetPropertyInfo     ,+++-- ** dBusMethodInvocationGetSender+    dBusMethodInvocationGetSender           ,+++-- ** dBusMethodInvocationReturnDbusError+    dBusMethodInvocationReturnDbusError     ,+++-- ** dBusMethodInvocationReturnErrorLiteral+    dBusMethodInvocationReturnErrorLiteral  ,+++-- ** dBusMethodInvocationReturnGerror+    dBusMethodInvocationReturnGerror        ,+++-- ** dBusMethodInvocationReturnValue+    dBusMethodInvocationReturnValue         ,+++-- ** dBusMethodInvocationReturnValueWithUnixFdList+    dBusMethodInvocationReturnValueWithUnixFdList,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype DBusMethodInvocation = DBusMethodInvocation (ForeignPtr DBusMethodInvocation)+foreign import ccall "g_dbus_method_invocation_get_type"+    c_g_dbus_method_invocation_get_type :: IO GType++type instance ParentTypes DBusMethodInvocation = DBusMethodInvocationParentTypes+type DBusMethodInvocationParentTypes = '[GObject.Object]++instance GObject DBusMethodInvocation where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_dbus_method_invocation_get_type+    ++class GObject o => DBusMethodInvocationK o+instance (GObject o, IsDescendantOf DBusMethodInvocation o) => DBusMethodInvocationK o++toDBusMethodInvocation :: DBusMethodInvocationK o => o -> IO DBusMethodInvocation+toDBusMethodInvocation = unsafeCastTo DBusMethodInvocation++noDBusMethodInvocation :: Maybe DBusMethodInvocation+noDBusMethodInvocation = Nothing++type instance AttributeList DBusMethodInvocation = DBusMethodInvocationAttributeList+type DBusMethodInvocationAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList DBusMethodInvocation = DBusMethodInvocationSignalList+type DBusMethodInvocationSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method DBusMethodInvocation::get_connection+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMethodInvocation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMethodInvocation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusConnection"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_method_invocation_get_connection" g_dbus_method_invocation_get_connection :: +    Ptr DBusMethodInvocation ->             -- _obj : TInterface "Gio" "DBusMethodInvocation"+    IO (Ptr DBusConnection)+++dBusMethodInvocationGetConnection ::+    (MonadIO m, DBusMethodInvocationK a) =>+    a ->                                    -- _obj+    m DBusConnection+dBusMethodInvocationGetConnection _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_method_invocation_get_connection _obj'+    checkUnexpectedReturnNULL "g_dbus_method_invocation_get_connection" result+    result' <- (newObject DBusConnection) result+    touchManagedPtr _obj+    return result'++-- method DBusMethodInvocation::get_interface_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMethodInvocation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMethodInvocation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_method_invocation_get_interface_name" g_dbus_method_invocation_get_interface_name :: +    Ptr DBusMethodInvocation ->             -- _obj : TInterface "Gio" "DBusMethodInvocation"+    IO CString+++dBusMethodInvocationGetInterfaceName ::+    (MonadIO m, DBusMethodInvocationK a) =>+    a ->                                    -- _obj+    m T.Text+dBusMethodInvocationGetInterfaceName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_method_invocation_get_interface_name _obj'+    checkUnexpectedReturnNULL "g_dbus_method_invocation_get_interface_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method DBusMethodInvocation::get_message+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMethodInvocation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMethodInvocation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusMessage"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_method_invocation_get_message" g_dbus_method_invocation_get_message :: +    Ptr DBusMethodInvocation ->             -- _obj : TInterface "Gio" "DBusMethodInvocation"+    IO (Ptr DBusMessage)+++dBusMethodInvocationGetMessage ::+    (MonadIO m, DBusMethodInvocationK a) =>+    a ->                                    -- _obj+    m DBusMessage+dBusMethodInvocationGetMessage _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_method_invocation_get_message _obj'+    checkUnexpectedReturnNULL "g_dbus_method_invocation_get_message" result+    result' <- (newObject DBusMessage) result+    touchManagedPtr _obj+    return result'++-- method DBusMethodInvocation::get_method_info+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMethodInvocation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMethodInvocation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusMethodInfo"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_method_invocation_get_method_info" g_dbus_method_invocation_get_method_info :: +    Ptr DBusMethodInvocation ->             -- _obj : TInterface "Gio" "DBusMethodInvocation"+    IO (Ptr DBusMethodInfo)+++dBusMethodInvocationGetMethodInfo ::+    (MonadIO m, DBusMethodInvocationK a) =>+    a ->                                    -- _obj+    m DBusMethodInfo+dBusMethodInvocationGetMethodInfo _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_method_invocation_get_method_info _obj'+    checkUnexpectedReturnNULL "g_dbus_method_invocation_get_method_info" result+    result' <- (newBoxed DBusMethodInfo) result+    touchManagedPtr _obj+    return result'++-- method DBusMethodInvocation::get_method_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMethodInvocation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMethodInvocation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_method_invocation_get_method_name" g_dbus_method_invocation_get_method_name :: +    Ptr DBusMethodInvocation ->             -- _obj : TInterface "Gio" "DBusMethodInvocation"+    IO CString+++dBusMethodInvocationGetMethodName ::+    (MonadIO m, DBusMethodInvocationK a) =>+    a ->                                    -- _obj+    m T.Text+dBusMethodInvocationGetMethodName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_method_invocation_get_method_name _obj'+    checkUnexpectedReturnNULL "g_dbus_method_invocation_get_method_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method DBusMethodInvocation::get_object_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMethodInvocation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMethodInvocation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_method_invocation_get_object_path" g_dbus_method_invocation_get_object_path :: +    Ptr DBusMethodInvocation ->             -- _obj : TInterface "Gio" "DBusMethodInvocation"+    IO CString+++dBusMethodInvocationGetObjectPath ::+    (MonadIO m, DBusMethodInvocationK a) =>+    a ->                                    -- _obj+    m T.Text+dBusMethodInvocationGetObjectPath _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_method_invocation_get_object_path _obj'+    checkUnexpectedReturnNULL "g_dbus_method_invocation_get_object_path" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method DBusMethodInvocation::get_parameters+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMethodInvocation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMethodInvocation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TVariant+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_method_invocation_get_parameters" g_dbus_method_invocation_get_parameters :: +    Ptr DBusMethodInvocation ->             -- _obj : TInterface "Gio" "DBusMethodInvocation"+    IO (Ptr GVariant)+++dBusMethodInvocationGetParameters ::+    (MonadIO m, DBusMethodInvocationK a) =>+    a ->                                    -- _obj+    m GVariant+dBusMethodInvocationGetParameters _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_method_invocation_get_parameters _obj'+    checkUnexpectedReturnNULL "g_dbus_method_invocation_get_parameters" result+    result' <- newGVariantFromPtr result+    touchManagedPtr _obj+    return result'++-- method DBusMethodInvocation::get_property_info+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMethodInvocation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMethodInvocation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusPropertyInfo"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_method_invocation_get_property_info" g_dbus_method_invocation_get_property_info :: +    Ptr DBusMethodInvocation ->             -- _obj : TInterface "Gio" "DBusMethodInvocation"+    IO (Ptr DBusPropertyInfo)+++dBusMethodInvocationGetPropertyInfo ::+    (MonadIO m, DBusMethodInvocationK a) =>+    a ->                                    -- _obj+    m DBusPropertyInfo+dBusMethodInvocationGetPropertyInfo _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_method_invocation_get_property_info _obj'+    checkUnexpectedReturnNULL "g_dbus_method_invocation_get_property_info" result+    result' <- (newBoxed DBusPropertyInfo) result+    touchManagedPtr _obj+    return result'++-- method DBusMethodInvocation::get_sender+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMethodInvocation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMethodInvocation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_method_invocation_get_sender" g_dbus_method_invocation_get_sender :: +    Ptr DBusMethodInvocation ->             -- _obj : TInterface "Gio" "DBusMethodInvocation"+    IO CString+++dBusMethodInvocationGetSender ::+    (MonadIO m, DBusMethodInvocationK a) =>+    a ->                                    -- _obj+    m T.Text+dBusMethodInvocationGetSender _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_method_invocation_get_sender _obj'+    checkUnexpectedReturnNULL "g_dbus_method_invocation_get_sender" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method DBusMethodInvocation::return_dbus_error+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMethodInvocation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "error_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "error_message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMethodInvocation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "error_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "error_message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_method_invocation_return_dbus_error" g_dbus_method_invocation_return_dbus_error :: +    Ptr DBusMethodInvocation ->             -- _obj : TInterface "Gio" "DBusMethodInvocation"+    CString ->                              -- error_name : TBasicType TUTF8+    CString ->                              -- error_message : TBasicType TUTF8+    IO ()+++dBusMethodInvocationReturnDbusError ::+    (MonadIO m, DBusMethodInvocationK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- error_name+    T.Text ->                               -- error_message+    m ()+dBusMethodInvocationReturnDbusError _obj error_name error_message = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    error_name' <- textToCString error_name+    error_message' <- textToCString error_message+    g_dbus_method_invocation_return_dbus_error _obj' error_name' error_message'+    touchManagedPtr _obj+    freeMem error_name'+    freeMem error_message'+    return ()++-- method DBusMethodInvocation::return_error_literal+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMethodInvocation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "domain", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "code", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMethodInvocation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "domain", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "code", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_method_invocation_return_error_literal" g_dbus_method_invocation_return_error_literal :: +    Ptr DBusMethodInvocation ->             -- _obj : TInterface "Gio" "DBusMethodInvocation"+    Word32 ->                               -- domain : TBasicType TUInt32+    Int32 ->                                -- code : TBasicType TInt32+    CString ->                              -- message : TBasicType TUTF8+    IO ()+++dBusMethodInvocationReturnErrorLiteral ::+    (MonadIO m, DBusMethodInvocationK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- domain+    Int32 ->                                -- code+    T.Text ->                               -- message+    m ()+dBusMethodInvocationReturnErrorLiteral _obj domain code message = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    message' <- textToCString message+    g_dbus_method_invocation_return_error_literal _obj' domain code message'+    touchManagedPtr _obj+    freeMem message'+    return ()++-- method DBusMethodInvocation::return_gerror+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMethodInvocation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMethodInvocation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_method_invocation_return_gerror" g_dbus_method_invocation_return_gerror :: +    Ptr DBusMethodInvocation ->             -- _obj : TInterface "Gio" "DBusMethodInvocation"+    Ptr GError ->                           -- error : TError+    IO ()+++dBusMethodInvocationReturnGerror ::+    (MonadIO m, DBusMethodInvocationK a) =>+    a ->                                    -- _obj+    GError ->                               -- error+    m ()+dBusMethodInvocationReturnGerror _obj error_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let error_' = unsafeManagedPtrGetPtr error_+    g_dbus_method_invocation_return_gerror _obj' error_'+    touchManagedPtr _obj+    touchManagedPtr error_+    return ()++-- method DBusMethodInvocation::return_value+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMethodInvocation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameters", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMethodInvocation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameters", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_method_invocation_return_value" g_dbus_method_invocation_return_value :: +    Ptr DBusMethodInvocation ->             -- _obj : TInterface "Gio" "DBusMethodInvocation"+    Ptr GVariant ->                         -- parameters : TVariant+    IO ()+++dBusMethodInvocationReturnValue ::+    (MonadIO m, DBusMethodInvocationK a) =>+    a ->                                    -- _obj+    Maybe (GVariant) ->                     -- parameters+    m ()+dBusMethodInvocationReturnValue _obj parameters = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeParameters <- case parameters of+        Nothing -> return nullPtr+        Just jParameters -> do+            let jParameters' = unsafeManagedPtrGetPtr jParameters+            return jParameters'+    g_dbus_method_invocation_return_value _obj' maybeParameters+    touchManagedPtr _obj+    return ()++-- method DBusMethodInvocation::return_value_with_unix_fd_list+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMethodInvocation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameters", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fd_list", argType = TInterface "Gio" "UnixFDList", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMethodInvocation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameters", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fd_list", argType = TInterface "Gio" "UnixFDList", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_method_invocation_return_value_with_unix_fd_list" g_dbus_method_invocation_return_value_with_unix_fd_list :: +    Ptr DBusMethodInvocation ->             -- _obj : TInterface "Gio" "DBusMethodInvocation"+    Ptr GVariant ->                         -- parameters : TVariant+    Ptr UnixFDList ->                       -- fd_list : TInterface "Gio" "UnixFDList"+    IO ()+++dBusMethodInvocationReturnValueWithUnixFdList ::+    (MonadIO m, DBusMethodInvocationK a, UnixFDListK b) =>+    a ->                                    -- _obj+    Maybe (GVariant) ->                     -- parameters+    Maybe (b) ->                            -- fd_list+    m ()+dBusMethodInvocationReturnValueWithUnixFdList _obj parameters fd_list = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeParameters <- case parameters of+        Nothing -> return nullPtr+        Just jParameters -> do+            let jParameters' = unsafeManagedPtrGetPtr jParameters+            return jParameters'+    maybeFd_list <- case fd_list of+        Nothing -> return nullPtr+        Just jFd_list -> do+            let jFd_list' = unsafeManagedPtrCastPtr jFd_list+            return jFd_list'+    g_dbus_method_invocation_return_value_with_unix_fd_list _obj' maybeParameters maybeFd_list+    touchManagedPtr _obj+    whenJust fd_list touchManagedPtr+    return ()++
+ GI/Gio/Objects/DBusMethodInvocation.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Objects.DBusMethodInvocation where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype DBusMethodInvocation = DBusMethodInvocation (ForeignPtr DBusMethodInvocation)+instance GObject DBusMethodInvocation where+class GObject o => DBusMethodInvocationK o+instance (GObject o, IsDescendantOf DBusMethodInvocation o) => DBusMethodInvocationK o
+ GI/Gio/Objects/DBusObjectManagerClient.hs view
@@ -0,0 +1,911 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.DBusObjectManagerClient+    ( ++-- * Exported types+    DBusObjectManagerClient(..)             ,+    DBusObjectManagerClientK                ,+    toDBusObjectManagerClient               ,+    noDBusObjectManagerClient               ,+++ -- * Methods+-- ** dBusObjectManagerClientGetConnection+    dBusObjectManagerClientGetConnection    ,+++-- ** dBusObjectManagerClientGetFlags+    dBusObjectManagerClientGetFlags         ,+++-- ** dBusObjectManagerClientGetName+    dBusObjectManagerClientGetName          ,+++-- ** dBusObjectManagerClientGetNameOwner+    dBusObjectManagerClientGetNameOwner     ,+++-- ** dBusObjectManagerClientNew+    dBusObjectManagerClientNew              ,+++-- ** dBusObjectManagerClientNewFinish+    dBusObjectManagerClientNewFinish        ,+++-- ** dBusObjectManagerClientNewForBus+    dBusObjectManagerClientNewForBus        ,+++-- ** dBusObjectManagerClientNewForBusFinish+    dBusObjectManagerClientNewForBusFinish  ,+++-- ** dBusObjectManagerClientNewForBusSync+    dBusObjectManagerClientNewForBusSync    ,+++-- ** dBusObjectManagerClientNewSync+    dBusObjectManagerClientNewSync          ,+++++ -- * Properties+-- ** BusType+    DBusObjectManagerClientBusTypePropertyInfo,+    constructDBusObjectManagerClientBusType ,+++-- ** Connection+    DBusObjectManagerClientConnectionPropertyInfo,+    constructDBusObjectManagerClientConnection,+    getDBusObjectManagerClientConnection    ,+++-- ** Flags+    DBusObjectManagerClientFlagsPropertyInfo,+    constructDBusObjectManagerClientFlags   ,+    getDBusObjectManagerClientFlags         ,+++-- ** GetProxyTypeDestroyNotify+    DBusObjectManagerClientGetProxyTypeDestroyNotifyPropertyInfo,+    constructDBusObjectManagerClientGetProxyTypeDestroyNotify,+    getDBusObjectManagerClientGetProxyTypeDestroyNotify,+++-- ** GetProxyTypeFunc+    DBusObjectManagerClientGetProxyTypeFuncPropertyInfo,+    constructDBusObjectManagerClientGetProxyTypeFunc,+    getDBusObjectManagerClientGetProxyTypeFunc,+++-- ** GetProxyTypeUserData+    DBusObjectManagerClientGetProxyTypeUserDataPropertyInfo,+    constructDBusObjectManagerClientGetProxyTypeUserData,+    getDBusObjectManagerClientGetProxyTypeUserData,+++-- ** Name+    DBusObjectManagerClientNamePropertyInfo ,+    constructDBusObjectManagerClientName    ,+    getDBusObjectManagerClientName          ,+++-- ** NameOwner+    DBusObjectManagerClientNameOwnerPropertyInfo,+    getDBusObjectManagerClientNameOwner     ,+++-- ** ObjectPath+    DBusObjectManagerClientObjectPathPropertyInfo,+    constructDBusObjectManagerClientObjectPath,+    getDBusObjectManagerClientObjectPath    ,+++++ -- * Signals+-- ** InterfaceProxyPropertiesChanged+    DBusObjectManagerClientInterfaceProxyPropertiesChangedCallback,+    DBusObjectManagerClientInterfaceProxyPropertiesChangedCallbackC,+    DBusObjectManagerClientInterfaceProxyPropertiesChangedSignalInfo,+    afterDBusObjectManagerClientInterfaceProxyPropertiesChanged,+    dBusObjectManagerClientInterfaceProxyPropertiesChangedCallbackWrapper,+    dBusObjectManagerClientInterfaceProxyPropertiesChangedClosure,+    mkDBusObjectManagerClientInterfaceProxyPropertiesChangedCallback,+    noDBusObjectManagerClientInterfaceProxyPropertiesChangedCallback,+    onDBusObjectManagerClientInterfaceProxyPropertiesChanged,+++-- ** InterfaceProxySignal+    DBusObjectManagerClientInterfaceProxySignalCallback,+    DBusObjectManagerClientInterfaceProxySignalCallbackC,+    DBusObjectManagerClientInterfaceProxySignalSignalInfo,+    afterDBusObjectManagerClientInterfaceProxySignal,+    dBusObjectManagerClientInterfaceProxySignalCallbackWrapper,+    dBusObjectManagerClientInterfaceProxySignalClosure,+    mkDBusObjectManagerClientInterfaceProxySignalCallback,+    noDBusObjectManagerClientInterfaceProxySignalCallback,+    onDBusObjectManagerClientInterfaceProxySignal,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype DBusObjectManagerClient = DBusObjectManagerClient (ForeignPtr DBusObjectManagerClient)+foreign import ccall "g_dbus_object_manager_client_get_type"+    c_g_dbus_object_manager_client_get_type :: IO GType++type instance ParentTypes DBusObjectManagerClient = DBusObjectManagerClientParentTypes+type DBusObjectManagerClientParentTypes = '[GObject.Object, AsyncInitable, DBusObjectManager, Initable]++instance GObject DBusObjectManagerClient where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_dbus_object_manager_client_get_type+    ++class GObject o => DBusObjectManagerClientK o+instance (GObject o, IsDescendantOf DBusObjectManagerClient o) => DBusObjectManagerClientK o++toDBusObjectManagerClient :: DBusObjectManagerClientK o => o -> IO DBusObjectManagerClient+toDBusObjectManagerClient = unsafeCastTo DBusObjectManagerClient++noDBusObjectManagerClient :: Maybe DBusObjectManagerClient+noDBusObjectManagerClient = Nothing++-- signal DBusObjectManagerClient::interface-proxy-properties-changed+type DBusObjectManagerClientInterfaceProxyPropertiesChangedCallback =+    DBusObjectProxy ->+    DBusProxy ->+    GVariant ->+    [T.Text] ->+    IO ()++noDBusObjectManagerClientInterfaceProxyPropertiesChangedCallback :: Maybe DBusObjectManagerClientInterfaceProxyPropertiesChangedCallback+noDBusObjectManagerClientInterfaceProxyPropertiesChangedCallback = Nothing++type DBusObjectManagerClientInterfaceProxyPropertiesChangedCallbackC =+    Ptr () ->                               -- object+    Ptr DBusObjectProxy ->+    Ptr DBusProxy ->+    Ptr GVariant ->+    Ptr CString ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkDBusObjectManagerClientInterfaceProxyPropertiesChangedCallback :: DBusObjectManagerClientInterfaceProxyPropertiesChangedCallbackC -> IO (FunPtr DBusObjectManagerClientInterfaceProxyPropertiesChangedCallbackC)++dBusObjectManagerClientInterfaceProxyPropertiesChangedClosure :: DBusObjectManagerClientInterfaceProxyPropertiesChangedCallback -> IO Closure+dBusObjectManagerClientInterfaceProxyPropertiesChangedClosure cb = newCClosure =<< mkDBusObjectManagerClientInterfaceProxyPropertiesChangedCallback wrapped+    where wrapped = dBusObjectManagerClientInterfaceProxyPropertiesChangedCallbackWrapper cb++dBusObjectManagerClientInterfaceProxyPropertiesChangedCallbackWrapper ::+    DBusObjectManagerClientInterfaceProxyPropertiesChangedCallback ->+    Ptr () ->+    Ptr DBusObjectProxy ->+    Ptr DBusProxy ->+    Ptr GVariant ->+    Ptr CString ->+    Ptr () ->+    IO ()+dBusObjectManagerClientInterfaceProxyPropertiesChangedCallbackWrapper _cb _ object_proxy interface_proxy changed_properties invalidated_properties _ = do+    object_proxy' <- (newObject DBusObjectProxy) object_proxy+    interface_proxy' <- (newObject DBusProxy) interface_proxy+    changed_properties' <- newGVariantFromPtr changed_properties+    invalidated_properties' <- unpackZeroTerminatedUTF8CArray invalidated_properties+    _cb  object_proxy' interface_proxy' changed_properties' invalidated_properties'++onDBusObjectManagerClientInterfaceProxyPropertiesChanged :: (GObject a, MonadIO m) => a -> DBusObjectManagerClientInterfaceProxyPropertiesChangedCallback -> m SignalHandlerId+onDBusObjectManagerClientInterfaceProxyPropertiesChanged obj cb = liftIO $ connectDBusObjectManagerClientInterfaceProxyPropertiesChanged obj cb SignalConnectBefore+afterDBusObjectManagerClientInterfaceProxyPropertiesChanged :: (GObject a, MonadIO m) => a -> DBusObjectManagerClientInterfaceProxyPropertiesChangedCallback -> m SignalHandlerId+afterDBusObjectManagerClientInterfaceProxyPropertiesChanged obj cb = connectDBusObjectManagerClientInterfaceProxyPropertiesChanged obj cb SignalConnectAfter++connectDBusObjectManagerClientInterfaceProxyPropertiesChanged :: (GObject a, MonadIO m) =>+                                                                 a -> DBusObjectManagerClientInterfaceProxyPropertiesChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectDBusObjectManagerClientInterfaceProxyPropertiesChanged obj cb after = liftIO $ do+    cb' <- mkDBusObjectManagerClientInterfaceProxyPropertiesChangedCallback (dBusObjectManagerClientInterfaceProxyPropertiesChangedCallbackWrapper cb)+    connectSignalFunPtr obj "interface-proxy-properties-changed" cb' after++-- signal DBusObjectManagerClient::interface-proxy-signal+type DBusObjectManagerClientInterfaceProxySignalCallback =+    DBusObjectProxy ->+    DBusProxy ->+    T.Text ->+    T.Text ->+    GVariant ->+    IO ()++noDBusObjectManagerClientInterfaceProxySignalCallback :: Maybe DBusObjectManagerClientInterfaceProxySignalCallback+noDBusObjectManagerClientInterfaceProxySignalCallback = Nothing++type DBusObjectManagerClientInterfaceProxySignalCallbackC =+    Ptr () ->                               -- object+    Ptr DBusObjectProxy ->+    Ptr DBusProxy ->+    CString ->+    CString ->+    Ptr GVariant ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkDBusObjectManagerClientInterfaceProxySignalCallback :: DBusObjectManagerClientInterfaceProxySignalCallbackC -> IO (FunPtr DBusObjectManagerClientInterfaceProxySignalCallbackC)++dBusObjectManagerClientInterfaceProxySignalClosure :: DBusObjectManagerClientInterfaceProxySignalCallback -> IO Closure+dBusObjectManagerClientInterfaceProxySignalClosure cb = newCClosure =<< mkDBusObjectManagerClientInterfaceProxySignalCallback wrapped+    where wrapped = dBusObjectManagerClientInterfaceProxySignalCallbackWrapper cb++dBusObjectManagerClientInterfaceProxySignalCallbackWrapper ::+    DBusObjectManagerClientInterfaceProxySignalCallback ->+    Ptr () ->+    Ptr DBusObjectProxy ->+    Ptr DBusProxy ->+    CString ->+    CString ->+    Ptr GVariant ->+    Ptr () ->+    IO ()+dBusObjectManagerClientInterfaceProxySignalCallbackWrapper _cb _ object_proxy interface_proxy sender_name signal_name parameters _ = do+    object_proxy' <- (newObject DBusObjectProxy) object_proxy+    interface_proxy' <- (newObject DBusProxy) interface_proxy+    sender_name' <- cstringToText sender_name+    signal_name' <- cstringToText signal_name+    parameters' <- newGVariantFromPtr parameters+    _cb  object_proxy' interface_proxy' sender_name' signal_name' parameters'++onDBusObjectManagerClientInterfaceProxySignal :: (GObject a, MonadIO m) => a -> DBusObjectManagerClientInterfaceProxySignalCallback -> m SignalHandlerId+onDBusObjectManagerClientInterfaceProxySignal obj cb = liftIO $ connectDBusObjectManagerClientInterfaceProxySignal obj cb SignalConnectBefore+afterDBusObjectManagerClientInterfaceProxySignal :: (GObject a, MonadIO m) => a -> DBusObjectManagerClientInterfaceProxySignalCallback -> m SignalHandlerId+afterDBusObjectManagerClientInterfaceProxySignal obj cb = connectDBusObjectManagerClientInterfaceProxySignal obj cb SignalConnectAfter++connectDBusObjectManagerClientInterfaceProxySignal :: (GObject a, MonadIO m) =>+                                                      a -> DBusObjectManagerClientInterfaceProxySignalCallback -> SignalConnectMode -> m SignalHandlerId+connectDBusObjectManagerClientInterfaceProxySignal obj cb after = liftIO $ do+    cb' <- mkDBusObjectManagerClientInterfaceProxySignalCallback (dBusObjectManagerClientInterfaceProxySignalCallbackWrapper cb)+    connectSignalFunPtr obj "interface-proxy-signal" cb' after++-- VVV Prop "bus-type"+   -- Type: TInterface "Gio" "BusType"+   -- Flags: [PropertyWritable,PropertyConstructOnly]++constructDBusObjectManagerClientBusType :: BusType -> IO ([Char], GValue)+constructDBusObjectManagerClientBusType val = constructObjectPropertyEnum "bus-type" val++data DBusObjectManagerClientBusTypePropertyInfo+instance AttrInfo DBusObjectManagerClientBusTypePropertyInfo where+    type AttrAllowedOps DBusObjectManagerClientBusTypePropertyInfo = '[ 'AttrConstruct]+    type AttrSetTypeConstraint DBusObjectManagerClientBusTypePropertyInfo = (~) BusType+    type AttrBaseTypeConstraint DBusObjectManagerClientBusTypePropertyInfo = DBusObjectManagerClientK+    type AttrGetType DBusObjectManagerClientBusTypePropertyInfo = ()+    type AttrLabel DBusObjectManagerClientBusTypePropertyInfo = "DBusObjectManagerClient::bus-type"+    attrGet _ = undefined+    attrSet _ = undefined+    attrConstruct _ = constructDBusObjectManagerClientBusType++-- VVV Prop "connection"+   -- Type: TInterface "Gio" "DBusConnection"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getDBusObjectManagerClientConnection :: (MonadIO m, DBusObjectManagerClientK o) => o -> m DBusConnection+getDBusObjectManagerClientConnection obj = liftIO $ getObjectPropertyObject obj "connection" DBusConnection++constructDBusObjectManagerClientConnection :: (DBusConnectionK a) => a -> IO ([Char], GValue)+constructDBusObjectManagerClientConnection val = constructObjectPropertyObject "connection" val++data DBusObjectManagerClientConnectionPropertyInfo+instance AttrInfo DBusObjectManagerClientConnectionPropertyInfo where+    type AttrAllowedOps DBusObjectManagerClientConnectionPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DBusObjectManagerClientConnectionPropertyInfo = DBusConnectionK+    type AttrBaseTypeConstraint DBusObjectManagerClientConnectionPropertyInfo = DBusObjectManagerClientK+    type AttrGetType DBusObjectManagerClientConnectionPropertyInfo = DBusConnection+    type AttrLabel DBusObjectManagerClientConnectionPropertyInfo = "DBusObjectManagerClient::connection"+    attrGet _ = getDBusObjectManagerClientConnection+    attrSet _ = undefined+    attrConstruct _ = constructDBusObjectManagerClientConnection++-- VVV Prop "flags"+   -- Type: TInterface "Gio" "DBusObjectManagerClientFlags"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getDBusObjectManagerClientFlags :: (MonadIO m, DBusObjectManagerClientK o) => o -> m [DBusObjectManagerClientFlags]+getDBusObjectManagerClientFlags obj = liftIO $ getObjectPropertyFlags obj "flags"++constructDBusObjectManagerClientFlags :: [DBusObjectManagerClientFlags] -> IO ([Char], GValue)+constructDBusObjectManagerClientFlags val = constructObjectPropertyFlags "flags" val++data DBusObjectManagerClientFlagsPropertyInfo+instance AttrInfo DBusObjectManagerClientFlagsPropertyInfo where+    type AttrAllowedOps DBusObjectManagerClientFlagsPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DBusObjectManagerClientFlagsPropertyInfo = (~) [DBusObjectManagerClientFlags]+    type AttrBaseTypeConstraint DBusObjectManagerClientFlagsPropertyInfo = DBusObjectManagerClientK+    type AttrGetType DBusObjectManagerClientFlagsPropertyInfo = [DBusObjectManagerClientFlags]+    type AttrLabel DBusObjectManagerClientFlagsPropertyInfo = "DBusObjectManagerClient::flags"+    attrGet _ = getDBusObjectManagerClientFlags+    attrSet _ = undefined+    attrConstruct _ = constructDBusObjectManagerClientFlags++-- VVV Prop "get-proxy-type-destroy-notify"+   -- Type: TBasicType TVoid+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getDBusObjectManagerClientGetProxyTypeDestroyNotify :: (MonadIO m, DBusObjectManagerClientK o) => o -> m (Ptr ())+getDBusObjectManagerClientGetProxyTypeDestroyNotify obj = liftIO $ getObjectPropertyPtr obj "get-proxy-type-destroy-notify"++constructDBusObjectManagerClientGetProxyTypeDestroyNotify :: (Ptr ()) -> IO ([Char], GValue)+constructDBusObjectManagerClientGetProxyTypeDestroyNotify val = constructObjectPropertyPtr "get-proxy-type-destroy-notify" val++data DBusObjectManagerClientGetProxyTypeDestroyNotifyPropertyInfo+instance AttrInfo DBusObjectManagerClientGetProxyTypeDestroyNotifyPropertyInfo where+    type AttrAllowedOps DBusObjectManagerClientGetProxyTypeDestroyNotifyPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DBusObjectManagerClientGetProxyTypeDestroyNotifyPropertyInfo = (~) (Ptr ())+    type AttrBaseTypeConstraint DBusObjectManagerClientGetProxyTypeDestroyNotifyPropertyInfo = DBusObjectManagerClientK+    type AttrGetType DBusObjectManagerClientGetProxyTypeDestroyNotifyPropertyInfo = (Ptr ())+    type AttrLabel DBusObjectManagerClientGetProxyTypeDestroyNotifyPropertyInfo = "DBusObjectManagerClient::get-proxy-type-destroy-notify"+    attrGet _ = getDBusObjectManagerClientGetProxyTypeDestroyNotify+    attrSet _ = undefined+    attrConstruct _ = constructDBusObjectManagerClientGetProxyTypeDestroyNotify++-- VVV Prop "get-proxy-type-func"+   -- Type: TBasicType TVoid+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getDBusObjectManagerClientGetProxyTypeFunc :: (MonadIO m, DBusObjectManagerClientK o) => o -> m (Ptr ())+getDBusObjectManagerClientGetProxyTypeFunc obj = liftIO $ getObjectPropertyPtr obj "get-proxy-type-func"++constructDBusObjectManagerClientGetProxyTypeFunc :: (Ptr ()) -> IO ([Char], GValue)+constructDBusObjectManagerClientGetProxyTypeFunc val = constructObjectPropertyPtr "get-proxy-type-func" val++data DBusObjectManagerClientGetProxyTypeFuncPropertyInfo+instance AttrInfo DBusObjectManagerClientGetProxyTypeFuncPropertyInfo where+    type AttrAllowedOps DBusObjectManagerClientGetProxyTypeFuncPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DBusObjectManagerClientGetProxyTypeFuncPropertyInfo = (~) (Ptr ())+    type AttrBaseTypeConstraint DBusObjectManagerClientGetProxyTypeFuncPropertyInfo = DBusObjectManagerClientK+    type AttrGetType DBusObjectManagerClientGetProxyTypeFuncPropertyInfo = (Ptr ())+    type AttrLabel DBusObjectManagerClientGetProxyTypeFuncPropertyInfo = "DBusObjectManagerClient::get-proxy-type-func"+    attrGet _ = getDBusObjectManagerClientGetProxyTypeFunc+    attrSet _ = undefined+    attrConstruct _ = constructDBusObjectManagerClientGetProxyTypeFunc++-- VVV Prop "get-proxy-type-user-data"+   -- Type: TBasicType TVoid+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getDBusObjectManagerClientGetProxyTypeUserData :: (MonadIO m, DBusObjectManagerClientK o) => o -> m (Ptr ())+getDBusObjectManagerClientGetProxyTypeUserData obj = liftIO $ getObjectPropertyPtr obj "get-proxy-type-user-data"++constructDBusObjectManagerClientGetProxyTypeUserData :: (Ptr ()) -> IO ([Char], GValue)+constructDBusObjectManagerClientGetProxyTypeUserData val = constructObjectPropertyPtr "get-proxy-type-user-data" val++data DBusObjectManagerClientGetProxyTypeUserDataPropertyInfo+instance AttrInfo DBusObjectManagerClientGetProxyTypeUserDataPropertyInfo where+    type AttrAllowedOps DBusObjectManagerClientGetProxyTypeUserDataPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DBusObjectManagerClientGetProxyTypeUserDataPropertyInfo = (~) (Ptr ())+    type AttrBaseTypeConstraint DBusObjectManagerClientGetProxyTypeUserDataPropertyInfo = DBusObjectManagerClientK+    type AttrGetType DBusObjectManagerClientGetProxyTypeUserDataPropertyInfo = (Ptr ())+    type AttrLabel DBusObjectManagerClientGetProxyTypeUserDataPropertyInfo = "DBusObjectManagerClient::get-proxy-type-user-data"+    attrGet _ = getDBusObjectManagerClientGetProxyTypeUserData+    attrSet _ = undefined+    attrConstruct _ = constructDBusObjectManagerClientGetProxyTypeUserData++-- VVV Prop "name"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getDBusObjectManagerClientName :: (MonadIO m, DBusObjectManagerClientK o) => o -> m T.Text+getDBusObjectManagerClientName obj = liftIO $ getObjectPropertyString obj "name"++constructDBusObjectManagerClientName :: T.Text -> IO ([Char], GValue)+constructDBusObjectManagerClientName val = constructObjectPropertyString "name" val++data DBusObjectManagerClientNamePropertyInfo+instance AttrInfo DBusObjectManagerClientNamePropertyInfo where+    type AttrAllowedOps DBusObjectManagerClientNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DBusObjectManagerClientNamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint DBusObjectManagerClientNamePropertyInfo = DBusObjectManagerClientK+    type AttrGetType DBusObjectManagerClientNamePropertyInfo = T.Text+    type AttrLabel DBusObjectManagerClientNamePropertyInfo = "DBusObjectManagerClient::name"+    attrGet _ = getDBusObjectManagerClientName+    attrSet _ = undefined+    attrConstruct _ = constructDBusObjectManagerClientName++-- VVV Prop "name-owner"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable]++getDBusObjectManagerClientNameOwner :: (MonadIO m, DBusObjectManagerClientK o) => o -> m T.Text+getDBusObjectManagerClientNameOwner obj = liftIO $ getObjectPropertyString obj "name-owner"++data DBusObjectManagerClientNameOwnerPropertyInfo+instance AttrInfo DBusObjectManagerClientNameOwnerPropertyInfo where+    type AttrAllowedOps DBusObjectManagerClientNameOwnerPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint DBusObjectManagerClientNameOwnerPropertyInfo = (~) ()+    type AttrBaseTypeConstraint DBusObjectManagerClientNameOwnerPropertyInfo = DBusObjectManagerClientK+    type AttrGetType DBusObjectManagerClientNameOwnerPropertyInfo = T.Text+    type AttrLabel DBusObjectManagerClientNameOwnerPropertyInfo = "DBusObjectManagerClient::name-owner"+    attrGet _ = getDBusObjectManagerClientNameOwner+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "object-path"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getDBusObjectManagerClientObjectPath :: (MonadIO m, DBusObjectManagerClientK o) => o -> m T.Text+getDBusObjectManagerClientObjectPath obj = liftIO $ getObjectPropertyString obj "object-path"++constructDBusObjectManagerClientObjectPath :: T.Text -> IO ([Char], GValue)+constructDBusObjectManagerClientObjectPath val = constructObjectPropertyString "object-path" val++data DBusObjectManagerClientObjectPathPropertyInfo+instance AttrInfo DBusObjectManagerClientObjectPathPropertyInfo where+    type AttrAllowedOps DBusObjectManagerClientObjectPathPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DBusObjectManagerClientObjectPathPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint DBusObjectManagerClientObjectPathPropertyInfo = DBusObjectManagerClientK+    type AttrGetType DBusObjectManagerClientObjectPathPropertyInfo = T.Text+    type AttrLabel DBusObjectManagerClientObjectPathPropertyInfo = "DBusObjectManagerClient::object-path"+    attrGet _ = getDBusObjectManagerClientObjectPath+    attrSet _ = undefined+    attrConstruct _ = constructDBusObjectManagerClientObjectPath++type instance AttributeList DBusObjectManagerClient = DBusObjectManagerClientAttributeList+type DBusObjectManagerClientAttributeList = ('[ '("bus-type", DBusObjectManagerClientBusTypePropertyInfo), '("connection", DBusObjectManagerClientConnectionPropertyInfo), '("flags", DBusObjectManagerClientFlagsPropertyInfo), '("get-proxy-type-destroy-notify", DBusObjectManagerClientGetProxyTypeDestroyNotifyPropertyInfo), '("get-proxy-type-func", DBusObjectManagerClientGetProxyTypeFuncPropertyInfo), '("get-proxy-type-user-data", DBusObjectManagerClientGetProxyTypeUserDataPropertyInfo), '("name", DBusObjectManagerClientNamePropertyInfo), '("name-owner", DBusObjectManagerClientNameOwnerPropertyInfo), '("object-path", DBusObjectManagerClientObjectPathPropertyInfo)] :: [(Symbol, *)])++data DBusObjectManagerClientInterfaceProxyPropertiesChangedSignalInfo+instance SignalInfo DBusObjectManagerClientInterfaceProxyPropertiesChangedSignalInfo where+    type HaskellCallbackType DBusObjectManagerClientInterfaceProxyPropertiesChangedSignalInfo = DBusObjectManagerClientInterfaceProxyPropertiesChangedCallback+    connectSignal _ = connectDBusObjectManagerClientInterfaceProxyPropertiesChanged++data DBusObjectManagerClientInterfaceProxySignalSignalInfo+instance SignalInfo DBusObjectManagerClientInterfaceProxySignalSignalInfo where+    type HaskellCallbackType DBusObjectManagerClientInterfaceProxySignalSignalInfo = DBusObjectManagerClientInterfaceProxySignalCallback+    connectSignal _ = connectDBusObjectManagerClientInterfaceProxySignal++type instance SignalList DBusObjectManagerClient = DBusObjectManagerClientSignalList+type DBusObjectManagerClientSignalList = ('[ '("interface-added", DBusObjectManagerInterfaceAddedSignalInfo), '("interface-proxy-properties-changed", DBusObjectManagerClientInterfaceProxyPropertiesChangedSignalInfo), '("interface-proxy-signal", DBusObjectManagerClientInterfaceProxySignalSignalInfo), '("interface-removed", DBusObjectManagerInterfaceRemovedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("object-added", DBusObjectManagerObjectAddedSignalInfo), '("object-removed", DBusObjectManagerObjectRemovedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method DBusObjectManagerClient::new_finish+-- method type : Constructor+-- Args : [Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusObjectManagerClient"+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_object_manager_client_new_finish" g_dbus_object_manager_client_new_finish :: +    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr DBusObjectManagerClient)+++dBusObjectManagerClientNewFinish ::+    (MonadIO m, AsyncResultK a) =>+    a ->                                    -- res+    m DBusObjectManagerClient+dBusObjectManagerClientNewFinish res = liftIO $ do+    let res' = unsafeManagedPtrCastPtr res+    onException (do+        result <- propagateGError $ g_dbus_object_manager_client_new_finish res'+        checkUnexpectedReturnNULL "g_dbus_object_manager_client_new_finish" result+        result' <- (wrapObject DBusObjectManagerClient) result+        touchManagedPtr res+        return result'+     ) (do+        return ()+     )++-- method DBusObjectManagerClient::new_for_bus_finish+-- method type : Constructor+-- Args : [Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusObjectManagerClient"+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_object_manager_client_new_for_bus_finish" g_dbus_object_manager_client_new_for_bus_finish :: +    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr DBusObjectManagerClient)+++dBusObjectManagerClientNewForBusFinish ::+    (MonadIO m, AsyncResultK a) =>+    a ->                                    -- res+    m DBusObjectManagerClient+dBusObjectManagerClientNewForBusFinish res = liftIO $ do+    let res' = unsafeManagedPtrCastPtr res+    onException (do+        result <- propagateGError $ g_dbus_object_manager_client_new_for_bus_finish res'+        checkUnexpectedReturnNULL "g_dbus_object_manager_client_new_for_bus_finish" result+        result' <- (wrapObject DBusObjectManagerClient) result+        touchManagedPtr res+        return result'+     ) (do+        return ()+     )++-- method DBusObjectManagerClient::new_for_bus_sync+-- method type : Constructor+-- Args : [Arg {argName = "bus_type", argType = TInterface "Gio" "BusType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusObjectManagerClientFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "get_proxy_type_func", argType = TInterface "Gio" "DBusProxyTypeFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeNotified, argClosure = 5, argDestroy = 6, transfer = TransferNothing},Arg {argName = "get_proxy_type_user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "get_proxy_type_destroy_notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "bus_type", argType = TInterface "Gio" "BusType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusObjectManagerClientFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "get_proxy_type_func", argType = TInterface "Gio" "DBusProxyTypeFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeNotified, argClosure = 5, argDestroy = 6, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusObjectManagerClient"+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_object_manager_client_new_for_bus_sync" g_dbus_object_manager_client_new_for_bus_sync :: +    CUInt ->                                -- bus_type : TInterface "Gio" "BusType"+    CUInt ->                                -- flags : TInterface "Gio" "DBusObjectManagerClientFlags"+    CString ->                              -- name : TBasicType TUTF8+    CString ->                              -- object_path : TBasicType TUTF8+    FunPtr DBusProxyTypeFuncC ->            -- get_proxy_type_func : TInterface "Gio" "DBusProxyTypeFunc"+    Ptr () ->                               -- get_proxy_type_user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- get_proxy_type_destroy_notify : TInterface "GLib" "DestroyNotify"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr DBusObjectManagerClient)+++dBusObjectManagerClientNewForBusSync ::+    (MonadIO m, CancellableK a) =>+    BusType ->                              -- bus_type+    [DBusObjectManagerClientFlags] ->       -- flags+    T.Text ->                               -- name+    T.Text ->                               -- object_path+    Maybe (DBusProxyTypeFunc) ->            -- get_proxy_type_func+    Maybe (a) ->                            -- cancellable+    m DBusObjectManagerClient+dBusObjectManagerClientNewForBusSync bus_type flags name object_path get_proxy_type_func_ cancellable = liftIO $ do+    let bus_type' = (fromIntegral . fromEnum) bus_type+    let flags' = gflagsToWord flags+    name' <- textToCString name+    object_path' <- textToCString object_path+    maybeGet_proxy_type_func_ <- case get_proxy_type_func_ of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jGet_proxy_type_func_ -> do+            jGet_proxy_type_func_' <- mkDBusProxyTypeFunc (dBusProxyTypeFuncWrapper Nothing jGet_proxy_type_func_)+            return jGet_proxy_type_func_'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    let get_proxy_type_user_data_ = castFunPtrToPtr maybeGet_proxy_type_func_+    let get_proxy_type_destroy_notify_ = safeFreeFunPtrPtr+    onException (do+        result <- propagateGError $ g_dbus_object_manager_client_new_for_bus_sync bus_type' flags' name' object_path' maybeGet_proxy_type_func_ get_proxy_type_user_data_ get_proxy_type_destroy_notify_ maybeCancellable+        checkUnexpectedReturnNULL "g_dbus_object_manager_client_new_for_bus_sync" result+        result' <- (wrapObject DBusObjectManagerClient) result+        whenJust cancellable touchManagedPtr+        freeMem name'+        freeMem object_path'+        return result'+     ) (do+        freeMem name'+        freeMem object_path'+     )++-- method DBusObjectManagerClient::new_sync+-- method type : Constructor+-- Args : [Arg {argName = "connection", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusObjectManagerClientFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "get_proxy_type_func", argType = TInterface "Gio" "DBusProxyTypeFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeNotified, argClosure = 5, argDestroy = 6, transfer = TransferNothing},Arg {argName = "get_proxy_type_user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "get_proxy_type_destroy_notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "connection", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusObjectManagerClientFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "get_proxy_type_func", argType = TInterface "Gio" "DBusProxyTypeFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeNotified, argClosure = 5, argDestroy = 6, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusObjectManagerClient"+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_object_manager_client_new_sync" g_dbus_object_manager_client_new_sync :: +    Ptr DBusConnection ->                   -- connection : TInterface "Gio" "DBusConnection"+    CUInt ->                                -- flags : TInterface "Gio" "DBusObjectManagerClientFlags"+    CString ->                              -- name : TBasicType TUTF8+    CString ->                              -- object_path : TBasicType TUTF8+    FunPtr DBusProxyTypeFuncC ->            -- get_proxy_type_func : TInterface "Gio" "DBusProxyTypeFunc"+    Ptr () ->                               -- get_proxy_type_user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- get_proxy_type_destroy_notify : TInterface "GLib" "DestroyNotify"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr DBusObjectManagerClient)+++dBusObjectManagerClientNewSync ::+    (MonadIO m, DBusConnectionK a, CancellableK b) =>+    a ->                                    -- connection+    [DBusObjectManagerClientFlags] ->       -- flags+    Maybe (T.Text) ->                       -- name+    T.Text ->                               -- object_path+    Maybe (DBusProxyTypeFunc) ->            -- get_proxy_type_func+    Maybe (b) ->                            -- cancellable+    m DBusObjectManagerClient+dBusObjectManagerClientNewSync connection flags name object_path get_proxy_type_func_ cancellable = liftIO $ do+    let connection' = unsafeManagedPtrCastPtr connection+    let flags' = gflagsToWord flags+    maybeName <- case name of+        Nothing -> return nullPtr+        Just jName -> do+            jName' <- textToCString jName+            return jName'+    object_path' <- textToCString object_path+    maybeGet_proxy_type_func_ <- case get_proxy_type_func_ of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jGet_proxy_type_func_ -> do+            jGet_proxy_type_func_' <- mkDBusProxyTypeFunc (dBusProxyTypeFuncWrapper Nothing jGet_proxy_type_func_)+            return jGet_proxy_type_func_'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    let get_proxy_type_user_data_ = castFunPtrToPtr maybeGet_proxy_type_func_+    let get_proxy_type_destroy_notify_ = safeFreeFunPtrPtr+    onException (do+        result <- propagateGError $ g_dbus_object_manager_client_new_sync connection' flags' maybeName object_path' maybeGet_proxy_type_func_ get_proxy_type_user_data_ get_proxy_type_destroy_notify_ maybeCancellable+        checkUnexpectedReturnNULL "g_dbus_object_manager_client_new_sync" result+        result' <- (wrapObject DBusObjectManagerClient) result+        touchManagedPtr connection+        whenJust cancellable touchManagedPtr+        freeMem maybeName+        freeMem object_path'+        return result'+     ) (do+        freeMem maybeName+        freeMem object_path'+     )++-- method DBusObjectManagerClient::get_connection+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectManagerClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectManagerClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusConnection"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_object_manager_client_get_connection" g_dbus_object_manager_client_get_connection :: +    Ptr DBusObjectManagerClient ->          -- _obj : TInterface "Gio" "DBusObjectManagerClient"+    IO (Ptr DBusConnection)+++dBusObjectManagerClientGetConnection ::+    (MonadIO m, DBusObjectManagerClientK a) =>+    a ->                                    -- _obj+    m DBusConnection+dBusObjectManagerClientGetConnection _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_object_manager_client_get_connection _obj'+    checkUnexpectedReturnNULL "g_dbus_object_manager_client_get_connection" result+    result' <- (newObject DBusConnection) result+    touchManagedPtr _obj+    return result'++-- method DBusObjectManagerClient::get_flags+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectManagerClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectManagerClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusObjectManagerClientFlags"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_object_manager_client_get_flags" g_dbus_object_manager_client_get_flags :: +    Ptr DBusObjectManagerClient ->          -- _obj : TInterface "Gio" "DBusObjectManagerClient"+    IO CUInt+++dBusObjectManagerClientGetFlags ::+    (MonadIO m, DBusObjectManagerClientK a) =>+    a ->                                    -- _obj+    m [DBusObjectManagerClientFlags]+dBusObjectManagerClientGetFlags _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_object_manager_client_get_flags _obj'+    let result' = wordToGFlags result+    touchManagedPtr _obj+    return result'++-- method DBusObjectManagerClient::get_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectManagerClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectManagerClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_object_manager_client_get_name" g_dbus_object_manager_client_get_name :: +    Ptr DBusObjectManagerClient ->          -- _obj : TInterface "Gio" "DBusObjectManagerClient"+    IO CString+++dBusObjectManagerClientGetName ::+    (MonadIO m, DBusObjectManagerClientK a) =>+    a ->                                    -- _obj+    m T.Text+dBusObjectManagerClientGetName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_object_manager_client_get_name _obj'+    checkUnexpectedReturnNULL "g_dbus_object_manager_client_get_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method DBusObjectManagerClient::get_name_owner+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectManagerClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectManagerClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_object_manager_client_get_name_owner" g_dbus_object_manager_client_get_name_owner :: +    Ptr DBusObjectManagerClient ->          -- _obj : TInterface "Gio" "DBusObjectManagerClient"+    IO CString+++dBusObjectManagerClientGetNameOwner ::+    (MonadIO m, DBusObjectManagerClientK a) =>+    a ->                                    -- _obj+    m T.Text+dBusObjectManagerClientGetNameOwner _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_object_manager_client_get_name_owner _obj'+    checkUnexpectedReturnNULL "g_dbus_object_manager_client_get_name_owner" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method DBusObjectManagerClient::new+-- method type : MemberFunction+-- Args : [Arg {argName = "connection", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusObjectManagerClientFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "get_proxy_type_func", argType = TInterface "Gio" "DBusProxyTypeFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeNotified, argClosure = 5, argDestroy = 6, transfer = TransferNothing},Arg {argName = "get_proxy_type_user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "get_proxy_type_destroy_notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 9, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "connection", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusObjectManagerClientFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "get_proxy_type_func", argType = TInterface "Gio" "DBusProxyTypeFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeNotified, argClosure = 5, argDestroy = 6, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 9, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_object_manager_client_new" g_dbus_object_manager_client_new :: +    Ptr DBusConnection ->                   -- connection : TInterface "Gio" "DBusConnection"+    CUInt ->                                -- flags : TInterface "Gio" "DBusObjectManagerClientFlags"+    CString ->                              -- name : TBasicType TUTF8+    CString ->                              -- object_path : TBasicType TUTF8+    FunPtr DBusProxyTypeFuncC ->            -- get_proxy_type_func : TInterface "Gio" "DBusProxyTypeFunc"+    Ptr () ->                               -- get_proxy_type_user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- get_proxy_type_destroy_notify : TInterface "GLib" "DestroyNotify"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++dBusObjectManagerClientNew ::+    (MonadIO m, DBusConnectionK a, CancellableK b) =>+    a ->                                    -- connection+    [DBusObjectManagerClientFlags] ->       -- flags+    T.Text ->                               -- name+    T.Text ->                               -- object_path+    Maybe (DBusProxyTypeFunc) ->            -- get_proxy_type_func+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+dBusObjectManagerClientNew connection flags name object_path get_proxy_type_func_ cancellable callback = liftIO $ do+    let connection' = unsafeManagedPtrCastPtr connection+    let flags' = gflagsToWord flags+    name' <- textToCString name+    object_path' <- textToCString object_path+    maybeGet_proxy_type_func_ <- case get_proxy_type_func_ of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jGet_proxy_type_func_ -> do+            jGet_proxy_type_func_' <- mkDBusProxyTypeFunc (dBusProxyTypeFuncWrapper Nothing jGet_proxy_type_func_)+            return jGet_proxy_type_func_'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let get_proxy_type_user_data_ = castFunPtrToPtr maybeGet_proxy_type_func_+    let get_proxy_type_destroy_notify_ = safeFreeFunPtrPtr+    let user_data = nullPtr+    g_dbus_object_manager_client_new connection' flags' name' object_path' maybeGet_proxy_type_func_ get_proxy_type_user_data_ get_proxy_type_destroy_notify_ maybeCancellable maybeCallback user_data+    touchManagedPtr connection+    whenJust cancellable touchManagedPtr+    freeMem name'+    freeMem object_path'+    return ()++-- method DBusObjectManagerClient::new_for_bus+-- method type : MemberFunction+-- Args : [Arg {argName = "bus_type", argType = TInterface "Gio" "BusType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusObjectManagerClientFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "get_proxy_type_func", argType = TInterface "Gio" "DBusProxyTypeFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeNotified, argClosure = 5, argDestroy = 6, transfer = TransferNothing},Arg {argName = "get_proxy_type_user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "get_proxy_type_destroy_notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 9, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "bus_type", argType = TInterface "Gio" "BusType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusObjectManagerClientFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "get_proxy_type_func", argType = TInterface "Gio" "DBusProxyTypeFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeNotified, argClosure = 5, argDestroy = 6, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 9, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_object_manager_client_new_for_bus" g_dbus_object_manager_client_new_for_bus :: +    CUInt ->                                -- bus_type : TInterface "Gio" "BusType"+    CUInt ->                                -- flags : TInterface "Gio" "DBusObjectManagerClientFlags"+    CString ->                              -- name : TBasicType TUTF8+    CString ->                              -- object_path : TBasicType TUTF8+    FunPtr DBusProxyTypeFuncC ->            -- get_proxy_type_func : TInterface "Gio" "DBusProxyTypeFunc"+    Ptr () ->                               -- get_proxy_type_user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- get_proxy_type_destroy_notify : TInterface "GLib" "DestroyNotify"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++dBusObjectManagerClientNewForBus ::+    (MonadIO m, CancellableK a) =>+    BusType ->                              -- bus_type+    [DBusObjectManagerClientFlags] ->       -- flags+    T.Text ->                               -- name+    T.Text ->                               -- object_path+    Maybe (DBusProxyTypeFunc) ->            -- get_proxy_type_func+    Maybe (a) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+dBusObjectManagerClientNewForBus bus_type flags name object_path get_proxy_type_func_ cancellable callback = liftIO $ do+    let bus_type' = (fromIntegral . fromEnum) bus_type+    let flags' = gflagsToWord flags+    name' <- textToCString name+    object_path' <- textToCString object_path+    maybeGet_proxy_type_func_ <- case get_proxy_type_func_ of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jGet_proxy_type_func_ -> do+            jGet_proxy_type_func_' <- mkDBusProxyTypeFunc (dBusProxyTypeFuncWrapper Nothing jGet_proxy_type_func_)+            return jGet_proxy_type_func_'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let get_proxy_type_user_data_ = castFunPtrToPtr maybeGet_proxy_type_func_+    let get_proxy_type_destroy_notify_ = safeFreeFunPtrPtr+    let user_data = nullPtr+    g_dbus_object_manager_client_new_for_bus bus_type' flags' name' object_path' maybeGet_proxy_type_func_ get_proxy_type_user_data_ get_proxy_type_destroy_notify_ maybeCancellable maybeCallback user_data+    whenJust cancellable touchManagedPtr+    freeMem name'+    freeMem object_path'+    return ()++
+ GI/Gio/Objects/DBusObjectManagerClient.hs-boot view
@@ -0,0 +1,24 @@+module GI.Gio.Objects.DBusObjectManagerClient where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype DBusObjectManagerClient = DBusObjectManagerClient (ForeignPtr DBusObjectManagerClient)+instance GObject DBusObjectManagerClient where+class GObject o => DBusObjectManagerClientK o+instance (GObject o, IsDescendantOf DBusObjectManagerClient o) => DBusObjectManagerClientK o+data DBusObjectManagerClientBusTypePropertyInfo+data DBusObjectManagerClientConnectionPropertyInfo+data DBusObjectManagerClientFlagsPropertyInfo+data DBusObjectManagerClientGetProxyTypeDestroyNotifyPropertyInfo+data DBusObjectManagerClientGetProxyTypeFuncPropertyInfo+data DBusObjectManagerClientGetProxyTypeUserDataPropertyInfo+data DBusObjectManagerClientNamePropertyInfo+data DBusObjectManagerClientNameOwnerPropertyInfo+data DBusObjectManagerClientObjectPathPropertyInfo+data DBusObjectManagerClientInterfaceProxyPropertiesChangedSignalInfo+data DBusObjectManagerClientInterfaceProxySignalSignalInfo
+ GI/Gio/Objects/DBusObjectManagerServer.hs view
@@ -0,0 +1,348 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.DBusObjectManagerServer+    ( ++-- * Exported types+    DBusObjectManagerServer(..)             ,+    DBusObjectManagerServerK                ,+    toDBusObjectManagerServer               ,+    noDBusObjectManagerServer               ,+++ -- * Methods+-- ** dBusObjectManagerServerExport+    dBusObjectManagerServerExport           ,+++-- ** dBusObjectManagerServerExportUniquely+    dBusObjectManagerServerExportUniquely   ,+++-- ** dBusObjectManagerServerGetConnection+    dBusObjectManagerServerGetConnection    ,+++-- ** dBusObjectManagerServerIsExported+    dBusObjectManagerServerIsExported       ,+++-- ** dBusObjectManagerServerNew+    dBusObjectManagerServerNew              ,+++-- ** dBusObjectManagerServerSetConnection+    dBusObjectManagerServerSetConnection    ,+++-- ** dBusObjectManagerServerUnexport+    dBusObjectManagerServerUnexport         ,+++++ -- * Properties+-- ** Connection+    DBusObjectManagerServerConnectionPropertyInfo,+    constructDBusObjectManagerServerConnection,+    getDBusObjectManagerServerConnection    ,+    setDBusObjectManagerServerConnection    ,+++-- ** ObjectPath+    DBusObjectManagerServerObjectPathPropertyInfo,+    constructDBusObjectManagerServerObjectPath,+    getDBusObjectManagerServerObjectPath    ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype DBusObjectManagerServer = DBusObjectManagerServer (ForeignPtr DBusObjectManagerServer)+foreign import ccall "g_dbus_object_manager_server_get_type"+    c_g_dbus_object_manager_server_get_type :: IO GType++type instance ParentTypes DBusObjectManagerServer = DBusObjectManagerServerParentTypes+type DBusObjectManagerServerParentTypes = '[GObject.Object, DBusObjectManager]++instance GObject DBusObjectManagerServer where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_dbus_object_manager_server_get_type+    ++class GObject o => DBusObjectManagerServerK o+instance (GObject o, IsDescendantOf DBusObjectManagerServer o) => DBusObjectManagerServerK o++toDBusObjectManagerServer :: DBusObjectManagerServerK o => o -> IO DBusObjectManagerServer+toDBusObjectManagerServer = unsafeCastTo DBusObjectManagerServer++noDBusObjectManagerServer :: Maybe DBusObjectManagerServer+noDBusObjectManagerServer = Nothing++-- VVV Prop "connection"+   -- Type: TInterface "Gio" "DBusConnection"+   -- Flags: [PropertyReadable,PropertyWritable]++getDBusObjectManagerServerConnection :: (MonadIO m, DBusObjectManagerServerK o) => o -> m DBusConnection+getDBusObjectManagerServerConnection obj = liftIO $ getObjectPropertyObject obj "connection" DBusConnection++setDBusObjectManagerServerConnection :: (MonadIO m, DBusObjectManagerServerK o, DBusConnectionK a) => o -> a -> m ()+setDBusObjectManagerServerConnection obj val = liftIO $ setObjectPropertyObject obj "connection" val++constructDBusObjectManagerServerConnection :: (DBusConnectionK a) => a -> IO ([Char], GValue)+constructDBusObjectManagerServerConnection val = constructObjectPropertyObject "connection" val++data DBusObjectManagerServerConnectionPropertyInfo+instance AttrInfo DBusObjectManagerServerConnectionPropertyInfo where+    type AttrAllowedOps DBusObjectManagerServerConnectionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DBusObjectManagerServerConnectionPropertyInfo = DBusConnectionK+    type AttrBaseTypeConstraint DBusObjectManagerServerConnectionPropertyInfo = DBusObjectManagerServerK+    type AttrGetType DBusObjectManagerServerConnectionPropertyInfo = DBusConnection+    type AttrLabel DBusObjectManagerServerConnectionPropertyInfo = "DBusObjectManagerServer::connection"+    attrGet _ = getDBusObjectManagerServerConnection+    attrSet _ = setDBusObjectManagerServerConnection+    attrConstruct _ = constructDBusObjectManagerServerConnection++-- VVV Prop "object-path"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getDBusObjectManagerServerObjectPath :: (MonadIO m, DBusObjectManagerServerK o) => o -> m T.Text+getDBusObjectManagerServerObjectPath obj = liftIO $ getObjectPropertyString obj "object-path"++constructDBusObjectManagerServerObjectPath :: T.Text -> IO ([Char], GValue)+constructDBusObjectManagerServerObjectPath val = constructObjectPropertyString "object-path" val++data DBusObjectManagerServerObjectPathPropertyInfo+instance AttrInfo DBusObjectManagerServerObjectPathPropertyInfo where+    type AttrAllowedOps DBusObjectManagerServerObjectPathPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DBusObjectManagerServerObjectPathPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint DBusObjectManagerServerObjectPathPropertyInfo = DBusObjectManagerServerK+    type AttrGetType DBusObjectManagerServerObjectPathPropertyInfo = T.Text+    type AttrLabel DBusObjectManagerServerObjectPathPropertyInfo = "DBusObjectManagerServer::object-path"+    attrGet _ = getDBusObjectManagerServerObjectPath+    attrSet _ = undefined+    attrConstruct _ = constructDBusObjectManagerServerObjectPath++type instance AttributeList DBusObjectManagerServer = DBusObjectManagerServerAttributeList+type DBusObjectManagerServerAttributeList = ('[ '("connection", DBusObjectManagerServerConnectionPropertyInfo), '("object-path", DBusObjectManagerServerObjectPathPropertyInfo)] :: [(Symbol, *)])++type instance SignalList DBusObjectManagerServer = DBusObjectManagerServerSignalList+type DBusObjectManagerServerSignalList = ('[ '("interface-added", DBusObjectManagerInterfaceAddedSignalInfo), '("interface-removed", DBusObjectManagerInterfaceRemovedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("object-added", DBusObjectManagerObjectAddedSignalInfo), '("object-removed", DBusObjectManagerObjectRemovedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method DBusObjectManagerServer::new+-- method type : Constructor+-- Args : [Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusObjectManagerServer"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_object_manager_server_new" g_dbus_object_manager_server_new :: +    CString ->                              -- object_path : TBasicType TUTF8+    IO (Ptr DBusObjectManagerServer)+++dBusObjectManagerServerNew ::+    (MonadIO m) =>+    T.Text ->                               -- object_path+    m DBusObjectManagerServer+dBusObjectManagerServerNew object_path = liftIO $ do+    object_path' <- textToCString object_path+    result <- g_dbus_object_manager_server_new object_path'+    checkUnexpectedReturnNULL "g_dbus_object_manager_server_new" result+    result' <- (wrapObject DBusObjectManagerServer) result+    freeMem object_path'+    return result'++-- method DBusObjectManagerServer::export+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectManagerServer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object", argType = TInterface "Gio" "DBusObjectSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectManagerServer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object", argType = TInterface "Gio" "DBusObjectSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_object_manager_server_export" g_dbus_object_manager_server_export :: +    Ptr DBusObjectManagerServer ->          -- _obj : TInterface "Gio" "DBusObjectManagerServer"+    Ptr DBusObjectSkeleton ->               -- object : TInterface "Gio" "DBusObjectSkeleton"+    IO ()+++dBusObjectManagerServerExport ::+    (MonadIO m, DBusObjectManagerServerK a, DBusObjectSkeletonK b) =>+    a ->                                    -- _obj+    b ->                                    -- object+    m ()+dBusObjectManagerServerExport _obj object = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let object' = unsafeManagedPtrCastPtr object+    g_dbus_object_manager_server_export _obj' object'+    touchManagedPtr _obj+    touchManagedPtr object+    return ()++-- method DBusObjectManagerServer::export_uniquely+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectManagerServer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object", argType = TInterface "Gio" "DBusObjectSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectManagerServer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object", argType = TInterface "Gio" "DBusObjectSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_object_manager_server_export_uniquely" g_dbus_object_manager_server_export_uniquely :: +    Ptr DBusObjectManagerServer ->          -- _obj : TInterface "Gio" "DBusObjectManagerServer"+    Ptr DBusObjectSkeleton ->               -- object : TInterface "Gio" "DBusObjectSkeleton"+    IO ()+++dBusObjectManagerServerExportUniquely ::+    (MonadIO m, DBusObjectManagerServerK a, DBusObjectSkeletonK b) =>+    a ->                                    -- _obj+    b ->                                    -- object+    m ()+dBusObjectManagerServerExportUniquely _obj object = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let object' = unsafeManagedPtrCastPtr object+    g_dbus_object_manager_server_export_uniquely _obj' object'+    touchManagedPtr _obj+    touchManagedPtr object+    return ()++-- method DBusObjectManagerServer::get_connection+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectManagerServer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectManagerServer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusConnection"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_object_manager_server_get_connection" g_dbus_object_manager_server_get_connection :: +    Ptr DBusObjectManagerServer ->          -- _obj : TInterface "Gio" "DBusObjectManagerServer"+    IO (Ptr DBusConnection)+++dBusObjectManagerServerGetConnection ::+    (MonadIO m, DBusObjectManagerServerK a) =>+    a ->                                    -- _obj+    m DBusConnection+dBusObjectManagerServerGetConnection _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_object_manager_server_get_connection _obj'+    checkUnexpectedReturnNULL "g_dbus_object_manager_server_get_connection" result+    result' <- (wrapObject DBusConnection) result+    touchManagedPtr _obj+    return result'++-- method DBusObjectManagerServer::is_exported+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectManagerServer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object", argType = TInterface "Gio" "DBusObjectSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectManagerServer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object", argType = TInterface "Gio" "DBusObjectSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_object_manager_server_is_exported" g_dbus_object_manager_server_is_exported :: +    Ptr DBusObjectManagerServer ->          -- _obj : TInterface "Gio" "DBusObjectManagerServer"+    Ptr DBusObjectSkeleton ->               -- object : TInterface "Gio" "DBusObjectSkeleton"+    IO CInt+++dBusObjectManagerServerIsExported ::+    (MonadIO m, DBusObjectManagerServerK a, DBusObjectSkeletonK b) =>+    a ->                                    -- _obj+    b ->                                    -- object+    m Bool+dBusObjectManagerServerIsExported _obj object = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let object' = unsafeManagedPtrCastPtr object+    result <- g_dbus_object_manager_server_is_exported _obj' object'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr object+    return result'++-- method DBusObjectManagerServer::set_connection+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectManagerServer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "connection", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectManagerServer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "connection", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_object_manager_server_set_connection" g_dbus_object_manager_server_set_connection :: +    Ptr DBusObjectManagerServer ->          -- _obj : TInterface "Gio" "DBusObjectManagerServer"+    Ptr DBusConnection ->                   -- connection : TInterface "Gio" "DBusConnection"+    IO ()+++dBusObjectManagerServerSetConnection ::+    (MonadIO m, DBusObjectManagerServerK a, DBusConnectionK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- connection+    m ()+dBusObjectManagerServerSetConnection _obj connection = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeConnection <- case connection of+        Nothing -> return nullPtr+        Just jConnection -> do+            let jConnection' = unsafeManagedPtrCastPtr jConnection+            return jConnection'+    g_dbus_object_manager_server_set_connection _obj' maybeConnection+    touchManagedPtr _obj+    whenJust connection touchManagedPtr+    return ()++-- method DBusObjectManagerServer::unexport+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectManagerServer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectManagerServer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_object_manager_server_unexport" g_dbus_object_manager_server_unexport :: +    Ptr DBusObjectManagerServer ->          -- _obj : TInterface "Gio" "DBusObjectManagerServer"+    CString ->                              -- object_path : TBasicType TUTF8+    IO CInt+++dBusObjectManagerServerUnexport ::+    (MonadIO m, DBusObjectManagerServerK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- object_path+    m Bool+dBusObjectManagerServerUnexport _obj object_path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    object_path' <- textToCString object_path+    result <- g_dbus_object_manager_server_unexport _obj' object_path'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem object_path'+    return result'++
+ GI/Gio/Objects/DBusObjectManagerServer.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gio.Objects.DBusObjectManagerServer where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype DBusObjectManagerServer = DBusObjectManagerServer (ForeignPtr DBusObjectManagerServer)+instance GObject DBusObjectManagerServer where+class GObject o => DBusObjectManagerServerK o+instance (GObject o, IsDescendantOf DBusObjectManagerServer o) => DBusObjectManagerServerK o+data DBusObjectManagerServerConnectionPropertyInfo+data DBusObjectManagerServerObjectPathPropertyInfo
+ GI/Gio/Objects/DBusObjectProxy.hs view
@@ -0,0 +1,182 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.DBusObjectProxy+    ( ++-- * Exported types+    DBusObjectProxy(..)                     ,+    DBusObjectProxyK                        ,+    toDBusObjectProxy                       ,+    noDBusObjectProxy                       ,+++ -- * Methods+-- ** dBusObjectProxyGetConnection+    dBusObjectProxyGetConnection            ,+++-- ** dBusObjectProxyNew+    dBusObjectProxyNew                      ,+++++ -- * Properties+-- ** GConnection+    DBusObjectProxyGConnectionPropertyInfo  ,+    constructDBusObjectProxyGConnection     ,+    getDBusObjectProxyGConnection           ,+++-- ** GObjectPath+    DBusObjectProxyGObjectPathPropertyInfo  ,+    constructDBusObjectProxyGObjectPath     ,+    getDBusObjectProxyGObjectPath           ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype DBusObjectProxy = DBusObjectProxy (ForeignPtr DBusObjectProxy)+foreign import ccall "g_dbus_object_proxy_get_type"+    c_g_dbus_object_proxy_get_type :: IO GType++type instance ParentTypes DBusObjectProxy = DBusObjectProxyParentTypes+type DBusObjectProxyParentTypes = '[GObject.Object, DBusObject]++instance GObject DBusObjectProxy where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_dbus_object_proxy_get_type+    ++class GObject o => DBusObjectProxyK o+instance (GObject o, IsDescendantOf DBusObjectProxy o) => DBusObjectProxyK o++toDBusObjectProxy :: DBusObjectProxyK o => o -> IO DBusObjectProxy+toDBusObjectProxy = unsafeCastTo DBusObjectProxy++noDBusObjectProxy :: Maybe DBusObjectProxy+noDBusObjectProxy = Nothing++-- VVV Prop "g-connection"+   -- Type: TInterface "Gio" "DBusConnection"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getDBusObjectProxyGConnection :: (MonadIO m, DBusObjectProxyK o) => o -> m DBusConnection+getDBusObjectProxyGConnection obj = liftIO $ getObjectPropertyObject obj "g-connection" DBusConnection++constructDBusObjectProxyGConnection :: (DBusConnectionK a) => a -> IO ([Char], GValue)+constructDBusObjectProxyGConnection val = constructObjectPropertyObject "g-connection" val++data DBusObjectProxyGConnectionPropertyInfo+instance AttrInfo DBusObjectProxyGConnectionPropertyInfo where+    type AttrAllowedOps DBusObjectProxyGConnectionPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DBusObjectProxyGConnectionPropertyInfo = DBusConnectionK+    type AttrBaseTypeConstraint DBusObjectProxyGConnectionPropertyInfo = DBusObjectProxyK+    type AttrGetType DBusObjectProxyGConnectionPropertyInfo = DBusConnection+    type AttrLabel DBusObjectProxyGConnectionPropertyInfo = "DBusObjectProxy::g-connection"+    attrGet _ = getDBusObjectProxyGConnection+    attrSet _ = undefined+    attrConstruct _ = constructDBusObjectProxyGConnection++-- VVV Prop "g-object-path"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getDBusObjectProxyGObjectPath :: (MonadIO m, DBusObjectProxyK o) => o -> m T.Text+getDBusObjectProxyGObjectPath obj = liftIO $ getObjectPropertyString obj "g-object-path"++constructDBusObjectProxyGObjectPath :: T.Text -> IO ([Char], GValue)+constructDBusObjectProxyGObjectPath val = constructObjectPropertyString "g-object-path" val++data DBusObjectProxyGObjectPathPropertyInfo+instance AttrInfo DBusObjectProxyGObjectPathPropertyInfo where+    type AttrAllowedOps DBusObjectProxyGObjectPathPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DBusObjectProxyGObjectPathPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint DBusObjectProxyGObjectPathPropertyInfo = DBusObjectProxyK+    type AttrGetType DBusObjectProxyGObjectPathPropertyInfo = T.Text+    type AttrLabel DBusObjectProxyGObjectPathPropertyInfo = "DBusObjectProxy::g-object-path"+    attrGet _ = getDBusObjectProxyGObjectPath+    attrSet _ = undefined+    attrConstruct _ = constructDBusObjectProxyGObjectPath++type instance AttributeList DBusObjectProxy = DBusObjectProxyAttributeList+type DBusObjectProxyAttributeList = ('[ '("g-connection", DBusObjectProxyGConnectionPropertyInfo), '("g-object-path", DBusObjectProxyGObjectPathPropertyInfo)] :: [(Symbol, *)])++type instance SignalList DBusObjectProxy = DBusObjectProxySignalList+type DBusObjectProxySignalList = ('[ '("interface-added", DBusObjectInterfaceAddedSignalInfo), '("interface-removed", DBusObjectInterfaceRemovedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method DBusObjectProxy::new+-- method type : Constructor+-- Args : [Arg {argName = "connection", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "connection", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusObjectProxy"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_object_proxy_new" g_dbus_object_proxy_new :: +    Ptr DBusConnection ->                   -- connection : TInterface "Gio" "DBusConnection"+    CString ->                              -- object_path : TBasicType TUTF8+    IO (Ptr DBusObjectProxy)+++dBusObjectProxyNew ::+    (MonadIO m, DBusConnectionK a) =>+    a ->                                    -- connection+    T.Text ->                               -- object_path+    m DBusObjectProxy+dBusObjectProxyNew connection object_path = liftIO $ do+    let connection' = unsafeManagedPtrCastPtr connection+    object_path' <- textToCString object_path+    result <- g_dbus_object_proxy_new connection' object_path'+    checkUnexpectedReturnNULL "g_dbus_object_proxy_new" result+    result' <- (wrapObject DBusObjectProxy) result+    touchManagedPtr connection+    freeMem object_path'+    return result'++-- method DBusObjectProxy::get_connection+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusConnection"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_object_proxy_get_connection" g_dbus_object_proxy_get_connection :: +    Ptr DBusObjectProxy ->                  -- _obj : TInterface "Gio" "DBusObjectProxy"+    IO (Ptr DBusConnection)+++dBusObjectProxyGetConnection ::+    (MonadIO m, DBusObjectProxyK a) =>+    a ->                                    -- _obj+    m DBusConnection+dBusObjectProxyGetConnection _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_object_proxy_get_connection _obj'+    checkUnexpectedReturnNULL "g_dbus_object_proxy_get_connection" result+    result' <- (newObject DBusConnection) result+    touchManagedPtr _obj+    return result'++
+ GI/Gio/Objects/DBusObjectProxy.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gio.Objects.DBusObjectProxy where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype DBusObjectProxy = DBusObjectProxy (ForeignPtr DBusObjectProxy)+instance GObject DBusObjectProxy where+class GObject o => DBusObjectProxyK o+instance (GObject o, IsDescendantOf DBusObjectProxy o) => DBusObjectProxyK o+data DBusObjectProxyGConnectionPropertyInfo+data DBusObjectProxyGObjectPathPropertyInfo
+ GI/Gio/Objects/DBusObjectSkeleton.hs view
@@ -0,0 +1,349 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.DBusObjectSkeleton+    ( ++-- * Exported types+    DBusObjectSkeleton(..)                  ,+    DBusObjectSkeletonK                     ,+    toDBusObjectSkeleton                    ,+    noDBusObjectSkeleton                    ,+++ -- * Methods+-- ** dBusObjectSkeletonAddInterface+    dBusObjectSkeletonAddInterface          ,+++-- ** dBusObjectSkeletonFlush+    dBusObjectSkeletonFlush                 ,+++-- ** dBusObjectSkeletonNew+    dBusObjectSkeletonNew                   ,+++-- ** dBusObjectSkeletonRemoveInterface+    dBusObjectSkeletonRemoveInterface       ,+++-- ** dBusObjectSkeletonRemoveInterfaceByName+    dBusObjectSkeletonRemoveInterfaceByName ,+++-- ** dBusObjectSkeletonSetObjectPath+    dBusObjectSkeletonSetObjectPath         ,+++++ -- * Properties+-- ** GObjectPath+    DBusObjectSkeletonGObjectPathPropertyInfo,+    constructDBusObjectSkeletonGObjectPath  ,+    getDBusObjectSkeletonGObjectPath        ,+    setDBusObjectSkeletonGObjectPath        ,+++++ -- * Signals+-- ** AuthorizeMethod+    DBusObjectSkeletonAuthorizeMethodCallback,+    DBusObjectSkeletonAuthorizeMethodCallbackC,+    DBusObjectSkeletonAuthorizeMethodSignalInfo,+    afterDBusObjectSkeletonAuthorizeMethod  ,+    dBusObjectSkeletonAuthorizeMethodCallbackWrapper,+    dBusObjectSkeletonAuthorizeMethodClosure,+    mkDBusObjectSkeletonAuthorizeMethodCallback,+    noDBusObjectSkeletonAuthorizeMethodCallback,+    onDBusObjectSkeletonAuthorizeMethod     ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype DBusObjectSkeleton = DBusObjectSkeleton (ForeignPtr DBusObjectSkeleton)+foreign import ccall "g_dbus_object_skeleton_get_type"+    c_g_dbus_object_skeleton_get_type :: IO GType++type instance ParentTypes DBusObjectSkeleton = DBusObjectSkeletonParentTypes+type DBusObjectSkeletonParentTypes = '[GObject.Object, DBusObject]++instance GObject DBusObjectSkeleton where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_dbus_object_skeleton_get_type+    ++class GObject o => DBusObjectSkeletonK o+instance (GObject o, IsDescendantOf DBusObjectSkeleton o) => DBusObjectSkeletonK o++toDBusObjectSkeleton :: DBusObjectSkeletonK o => o -> IO DBusObjectSkeleton+toDBusObjectSkeleton = unsafeCastTo DBusObjectSkeleton++noDBusObjectSkeleton :: Maybe DBusObjectSkeleton+noDBusObjectSkeleton = Nothing++-- signal DBusObjectSkeleton::authorize-method+type DBusObjectSkeletonAuthorizeMethodCallback =+    DBusInterfaceSkeleton ->+    DBusMethodInvocation ->+    IO Bool++noDBusObjectSkeletonAuthorizeMethodCallback :: Maybe DBusObjectSkeletonAuthorizeMethodCallback+noDBusObjectSkeletonAuthorizeMethodCallback = Nothing++type DBusObjectSkeletonAuthorizeMethodCallbackC =+    Ptr () ->                               -- object+    Ptr DBusInterfaceSkeleton ->+    Ptr DBusMethodInvocation ->+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkDBusObjectSkeletonAuthorizeMethodCallback :: DBusObjectSkeletonAuthorizeMethodCallbackC -> IO (FunPtr DBusObjectSkeletonAuthorizeMethodCallbackC)++dBusObjectSkeletonAuthorizeMethodClosure :: DBusObjectSkeletonAuthorizeMethodCallback -> IO Closure+dBusObjectSkeletonAuthorizeMethodClosure cb = newCClosure =<< mkDBusObjectSkeletonAuthorizeMethodCallback wrapped+    where wrapped = dBusObjectSkeletonAuthorizeMethodCallbackWrapper cb++dBusObjectSkeletonAuthorizeMethodCallbackWrapper ::+    DBusObjectSkeletonAuthorizeMethodCallback ->+    Ptr () ->+    Ptr DBusInterfaceSkeleton ->+    Ptr DBusMethodInvocation ->+    Ptr () ->+    IO CInt+dBusObjectSkeletonAuthorizeMethodCallbackWrapper _cb _ interface invocation _ = do+    interface' <- (newObject DBusInterfaceSkeleton) interface+    invocation' <- (newObject DBusMethodInvocation) invocation+    result <- _cb  interface' invocation'+    let result' = (fromIntegral . fromEnum) result+    return result'++onDBusObjectSkeletonAuthorizeMethod :: (GObject a, MonadIO m) => a -> DBusObjectSkeletonAuthorizeMethodCallback -> m SignalHandlerId+onDBusObjectSkeletonAuthorizeMethod obj cb = liftIO $ connectDBusObjectSkeletonAuthorizeMethod obj cb SignalConnectBefore+afterDBusObjectSkeletonAuthorizeMethod :: (GObject a, MonadIO m) => a -> DBusObjectSkeletonAuthorizeMethodCallback -> m SignalHandlerId+afterDBusObjectSkeletonAuthorizeMethod obj cb = connectDBusObjectSkeletonAuthorizeMethod obj cb SignalConnectAfter++connectDBusObjectSkeletonAuthorizeMethod :: (GObject a, MonadIO m) =>+                                            a -> DBusObjectSkeletonAuthorizeMethodCallback -> SignalConnectMode -> m SignalHandlerId+connectDBusObjectSkeletonAuthorizeMethod obj cb after = liftIO $ do+    cb' <- mkDBusObjectSkeletonAuthorizeMethodCallback (dBusObjectSkeletonAuthorizeMethodCallbackWrapper cb)+    connectSignalFunPtr obj "authorize-method" cb' after++-- VVV Prop "g-object-path"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getDBusObjectSkeletonGObjectPath :: (MonadIO m, DBusObjectSkeletonK o) => o -> m T.Text+getDBusObjectSkeletonGObjectPath obj = liftIO $ getObjectPropertyString obj "g-object-path"++setDBusObjectSkeletonGObjectPath :: (MonadIO m, DBusObjectSkeletonK o) => o -> T.Text -> m ()+setDBusObjectSkeletonGObjectPath obj val = liftIO $ setObjectPropertyString obj "g-object-path" val++constructDBusObjectSkeletonGObjectPath :: T.Text -> IO ([Char], GValue)+constructDBusObjectSkeletonGObjectPath val = constructObjectPropertyString "g-object-path" val++data DBusObjectSkeletonGObjectPathPropertyInfo+instance AttrInfo DBusObjectSkeletonGObjectPathPropertyInfo where+    type AttrAllowedOps DBusObjectSkeletonGObjectPathPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DBusObjectSkeletonGObjectPathPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint DBusObjectSkeletonGObjectPathPropertyInfo = DBusObjectSkeletonK+    type AttrGetType DBusObjectSkeletonGObjectPathPropertyInfo = T.Text+    type AttrLabel DBusObjectSkeletonGObjectPathPropertyInfo = "DBusObjectSkeleton::g-object-path"+    attrGet _ = getDBusObjectSkeletonGObjectPath+    attrSet _ = setDBusObjectSkeletonGObjectPath+    attrConstruct _ = constructDBusObjectSkeletonGObjectPath++type instance AttributeList DBusObjectSkeleton = DBusObjectSkeletonAttributeList+type DBusObjectSkeletonAttributeList = ('[ '("g-object-path", DBusObjectSkeletonGObjectPathPropertyInfo)] :: [(Symbol, *)])++data DBusObjectSkeletonAuthorizeMethodSignalInfo+instance SignalInfo DBusObjectSkeletonAuthorizeMethodSignalInfo where+    type HaskellCallbackType DBusObjectSkeletonAuthorizeMethodSignalInfo = DBusObjectSkeletonAuthorizeMethodCallback+    connectSignal _ = connectDBusObjectSkeletonAuthorizeMethod++type instance SignalList DBusObjectSkeleton = DBusObjectSkeletonSignalList+type DBusObjectSkeletonSignalList = ('[ '("authorize-method", DBusObjectSkeletonAuthorizeMethodSignalInfo), '("interface-added", DBusObjectInterfaceAddedSignalInfo), '("interface-removed", DBusObjectInterfaceRemovedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method DBusObjectSkeleton::new+-- method type : Constructor+-- Args : [Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusObjectSkeleton"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_object_skeleton_new" g_dbus_object_skeleton_new :: +    CString ->                              -- object_path : TBasicType TUTF8+    IO (Ptr DBusObjectSkeleton)+++dBusObjectSkeletonNew ::+    (MonadIO m) =>+    T.Text ->                               -- object_path+    m DBusObjectSkeleton+dBusObjectSkeletonNew object_path = liftIO $ do+    object_path' <- textToCString object_path+    result <- g_dbus_object_skeleton_new object_path'+    checkUnexpectedReturnNULL "g_dbus_object_skeleton_new" result+    result' <- (wrapObject DBusObjectSkeleton) result+    freeMem object_path'+    return result'++-- method DBusObjectSkeleton::add_interface+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_", argType = TInterface "Gio" "DBusInterfaceSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_", argType = TInterface "Gio" "DBusInterfaceSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_object_skeleton_add_interface" g_dbus_object_skeleton_add_interface :: +    Ptr DBusObjectSkeleton ->               -- _obj : TInterface "Gio" "DBusObjectSkeleton"+    Ptr DBusInterfaceSkeleton ->            -- interface_ : TInterface "Gio" "DBusInterfaceSkeleton"+    IO ()+++dBusObjectSkeletonAddInterface ::+    (MonadIO m, DBusObjectSkeletonK a, DBusInterfaceSkeletonK b) =>+    a ->                                    -- _obj+    b ->                                    -- interface_+    m ()+dBusObjectSkeletonAddInterface _obj interface_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let interface_' = unsafeManagedPtrCastPtr interface_+    g_dbus_object_skeleton_add_interface _obj' interface_'+    touchManagedPtr _obj+    touchManagedPtr interface_+    return ()++-- method DBusObjectSkeleton::flush+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_object_skeleton_flush" g_dbus_object_skeleton_flush :: +    Ptr DBusObjectSkeleton ->               -- _obj : TInterface "Gio" "DBusObjectSkeleton"+    IO ()+++dBusObjectSkeletonFlush ::+    (MonadIO m, DBusObjectSkeletonK a) =>+    a ->                                    -- _obj+    m ()+dBusObjectSkeletonFlush _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_dbus_object_skeleton_flush _obj'+    touchManagedPtr _obj+    return ()++-- method DBusObjectSkeleton::remove_interface+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_", argType = TInterface "Gio" "DBusInterfaceSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_", argType = TInterface "Gio" "DBusInterfaceSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_object_skeleton_remove_interface" g_dbus_object_skeleton_remove_interface :: +    Ptr DBusObjectSkeleton ->               -- _obj : TInterface "Gio" "DBusObjectSkeleton"+    Ptr DBusInterfaceSkeleton ->            -- interface_ : TInterface "Gio" "DBusInterfaceSkeleton"+    IO ()+++dBusObjectSkeletonRemoveInterface ::+    (MonadIO m, DBusObjectSkeletonK a, DBusInterfaceSkeletonK b) =>+    a ->                                    -- _obj+    b ->                                    -- interface_+    m ()+dBusObjectSkeletonRemoveInterface _obj interface_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let interface_' = unsafeManagedPtrCastPtr interface_+    g_dbus_object_skeleton_remove_interface _obj' interface_'+    touchManagedPtr _obj+    touchManagedPtr interface_+    return ()++-- method DBusObjectSkeleton::remove_interface_by_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_object_skeleton_remove_interface_by_name" g_dbus_object_skeleton_remove_interface_by_name :: +    Ptr DBusObjectSkeleton ->               -- _obj : TInterface "Gio" "DBusObjectSkeleton"+    CString ->                              -- interface_name : TBasicType TUTF8+    IO ()+++dBusObjectSkeletonRemoveInterfaceByName ::+    (MonadIO m, DBusObjectSkeletonK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- interface_name+    m ()+dBusObjectSkeletonRemoveInterfaceByName _obj interface_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    interface_name' <- textToCString interface_name+    g_dbus_object_skeleton_remove_interface_by_name _obj' interface_name'+    touchManagedPtr _obj+    freeMem interface_name'+    return ()++-- method DBusObjectSkeleton::set_object_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusObjectSkeleton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_object_skeleton_set_object_path" g_dbus_object_skeleton_set_object_path :: +    Ptr DBusObjectSkeleton ->               -- _obj : TInterface "Gio" "DBusObjectSkeleton"+    CString ->                              -- object_path : TBasicType TUTF8+    IO ()+++dBusObjectSkeletonSetObjectPath ::+    (MonadIO m, DBusObjectSkeletonK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- object_path+    m ()+dBusObjectSkeletonSetObjectPath _obj object_path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    object_path' <- textToCString object_path+    g_dbus_object_skeleton_set_object_path _obj' object_path'+    touchManagedPtr _obj+    freeMem object_path'+    return ()++
+ GI/Gio/Objects/DBusObjectSkeleton.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gio.Objects.DBusObjectSkeleton where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype DBusObjectSkeleton = DBusObjectSkeleton (ForeignPtr DBusObjectSkeleton)+instance GObject DBusObjectSkeleton where+class GObject o => DBusObjectSkeletonK o+instance (GObject o, IsDescendantOf DBusObjectSkeleton o) => DBusObjectSkeletonK o+data DBusObjectSkeletonGObjectPathPropertyInfo+data DBusObjectSkeletonAuthorizeMethodSignalInfo
+ GI/Gio/Objects/DBusProxy.hs view
@@ -0,0 +1,1555 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.DBusProxy+    ( ++-- * Exported types+    DBusProxy(..)                           ,+    DBusProxyK                              ,+    toDBusProxy                             ,+    noDBusProxy                             ,+++ -- * Methods+-- ** dBusProxyCall+    dBusProxyCall                           ,+++-- ** dBusProxyCallFinish+    dBusProxyCallFinish                     ,+++-- ** dBusProxyCallSync+    dBusProxyCallSync                       ,+++-- ** dBusProxyCallWithUnixFdList+    dBusProxyCallWithUnixFdList             ,+++-- ** dBusProxyCallWithUnixFdListFinish+    dBusProxyCallWithUnixFdListFinish       ,+++-- ** dBusProxyCallWithUnixFdListSync+    dBusProxyCallWithUnixFdListSync         ,+++-- ** dBusProxyGetCachedProperty+    dBusProxyGetCachedProperty              ,+++-- ** dBusProxyGetCachedPropertyNames+    dBusProxyGetCachedPropertyNames         ,+++-- ** dBusProxyGetConnection+    dBusProxyGetConnection                  ,+++-- ** dBusProxyGetDefaultTimeout+    dBusProxyGetDefaultTimeout              ,+++-- ** dBusProxyGetFlags+    dBusProxyGetFlags                       ,+++-- ** dBusProxyGetInterfaceInfo+    dBusProxyGetInterfaceInfo               ,+++-- ** dBusProxyGetInterfaceName+    dBusProxyGetInterfaceName               ,+++-- ** dBusProxyGetName+    dBusProxyGetName                        ,+++-- ** dBusProxyGetNameOwner+    dBusProxyGetNameOwner                   ,+++-- ** dBusProxyGetObjectPath+    dBusProxyGetObjectPath                  ,+++-- ** dBusProxyNew+    dBusProxyNew                            ,+++-- ** dBusProxyNewFinish+    dBusProxyNewFinish                      ,+++-- ** dBusProxyNewForBus+    dBusProxyNewForBus                      ,+++-- ** dBusProxyNewForBusFinish+    dBusProxyNewForBusFinish                ,+++-- ** dBusProxyNewForBusSync+    dBusProxyNewForBusSync                  ,+++-- ** dBusProxyNewSync+    dBusProxyNewSync                        ,+++-- ** dBusProxySetCachedProperty+    dBusProxySetCachedProperty              ,+++-- ** dBusProxySetDefaultTimeout+    dBusProxySetDefaultTimeout              ,+++-- ** dBusProxySetInterfaceInfo+    dBusProxySetInterfaceInfo               ,+++++ -- * Properties+-- ** GBusType+    DBusProxyGBusTypePropertyInfo           ,+    constructDBusProxyGBusType              ,+++-- ** GConnection+    DBusProxyGConnectionPropertyInfo        ,+    constructDBusProxyGConnection           ,+    getDBusProxyGConnection                 ,+++-- ** GDefaultTimeout+    DBusProxyGDefaultTimeoutPropertyInfo    ,+    constructDBusProxyGDefaultTimeout       ,+    getDBusProxyGDefaultTimeout             ,+    setDBusProxyGDefaultTimeout             ,+++-- ** GFlags+    DBusProxyGFlagsPropertyInfo             ,+    constructDBusProxyGFlags                ,+    getDBusProxyGFlags                      ,+++-- ** GInterfaceInfo+    DBusProxyGInterfaceInfoPropertyInfo     ,+    constructDBusProxyGInterfaceInfo        ,+    getDBusProxyGInterfaceInfo              ,+    setDBusProxyGInterfaceInfo              ,+++-- ** GInterfaceName+    DBusProxyGInterfaceNamePropertyInfo     ,+    constructDBusProxyGInterfaceName        ,+    getDBusProxyGInterfaceName              ,+++-- ** GName+    DBusProxyGNamePropertyInfo              ,+    constructDBusProxyGName                 ,+    getDBusProxyGName                       ,+++-- ** GNameOwner+    DBusProxyGNameOwnerPropertyInfo         ,+    getDBusProxyGNameOwner                  ,+++-- ** GObjectPath+    DBusProxyGObjectPathPropertyInfo        ,+    constructDBusProxyGObjectPath           ,+    getDBusProxyGObjectPath                 ,+++++ -- * Signals+-- ** GPropertiesChanged+    DBusProxyGPropertiesChangedCallback     ,+    DBusProxyGPropertiesChangedCallbackC    ,+    DBusProxyGPropertiesChangedSignalInfo   ,+    afterDBusProxyGPropertiesChanged        ,+    dBusProxyGPropertiesChangedCallbackWrapper,+    dBusProxyGPropertiesChangedClosure      ,+    mkDBusProxyGPropertiesChangedCallback   ,+    noDBusProxyGPropertiesChangedCallback   ,+    onDBusProxyGPropertiesChanged           ,+++-- ** GSignal+    DBusProxyGSignalCallback                ,+    DBusProxyGSignalCallbackC               ,+    DBusProxyGSignalSignalInfo              ,+    afterDBusProxyGSignal                   ,+    dBusProxyGSignalCallbackWrapper         ,+    dBusProxyGSignalClosure                 ,+    mkDBusProxyGSignalCallback              ,+    noDBusProxyGSignalCallback              ,+    onDBusProxyGSignal                      ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype DBusProxy = DBusProxy (ForeignPtr DBusProxy)+foreign import ccall "g_dbus_proxy_get_type"+    c_g_dbus_proxy_get_type :: IO GType++type instance ParentTypes DBusProxy = DBusProxyParentTypes+type DBusProxyParentTypes = '[GObject.Object, AsyncInitable, DBusInterface, Initable]++instance GObject DBusProxy where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_dbus_proxy_get_type+    ++class GObject o => DBusProxyK o+instance (GObject o, IsDescendantOf DBusProxy o) => DBusProxyK o++toDBusProxy :: DBusProxyK o => o -> IO DBusProxy+toDBusProxy = unsafeCastTo DBusProxy++noDBusProxy :: Maybe DBusProxy+noDBusProxy = Nothing++-- signal DBusProxy::g-properties-changed+type DBusProxyGPropertiesChangedCallback =+    GVariant ->+    [T.Text] ->+    IO ()++noDBusProxyGPropertiesChangedCallback :: Maybe DBusProxyGPropertiesChangedCallback+noDBusProxyGPropertiesChangedCallback = Nothing++type DBusProxyGPropertiesChangedCallbackC =+    Ptr () ->                               -- object+    Ptr GVariant ->+    Ptr CString ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkDBusProxyGPropertiesChangedCallback :: DBusProxyGPropertiesChangedCallbackC -> IO (FunPtr DBusProxyGPropertiesChangedCallbackC)++dBusProxyGPropertiesChangedClosure :: DBusProxyGPropertiesChangedCallback -> IO Closure+dBusProxyGPropertiesChangedClosure cb = newCClosure =<< mkDBusProxyGPropertiesChangedCallback wrapped+    where wrapped = dBusProxyGPropertiesChangedCallbackWrapper cb++dBusProxyGPropertiesChangedCallbackWrapper ::+    DBusProxyGPropertiesChangedCallback ->+    Ptr () ->+    Ptr GVariant ->+    Ptr CString ->+    Ptr () ->+    IO ()+dBusProxyGPropertiesChangedCallbackWrapper _cb _ changed_properties invalidated_properties _ = do+    changed_properties' <- newGVariantFromPtr changed_properties+    invalidated_properties' <- unpackZeroTerminatedUTF8CArray invalidated_properties+    _cb  changed_properties' invalidated_properties'++onDBusProxyGPropertiesChanged :: (GObject a, MonadIO m) => a -> DBusProxyGPropertiesChangedCallback -> m SignalHandlerId+onDBusProxyGPropertiesChanged obj cb = liftIO $ connectDBusProxyGPropertiesChanged obj cb SignalConnectBefore+afterDBusProxyGPropertiesChanged :: (GObject a, MonadIO m) => a -> DBusProxyGPropertiesChangedCallback -> m SignalHandlerId+afterDBusProxyGPropertiesChanged obj cb = connectDBusProxyGPropertiesChanged obj cb SignalConnectAfter++connectDBusProxyGPropertiesChanged :: (GObject a, MonadIO m) =>+                                      a -> DBusProxyGPropertiesChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectDBusProxyGPropertiesChanged obj cb after = liftIO $ do+    cb' <- mkDBusProxyGPropertiesChangedCallback (dBusProxyGPropertiesChangedCallbackWrapper cb)+    connectSignalFunPtr obj "g-properties-changed" cb' after++-- signal DBusProxy::g-signal+type DBusProxyGSignalCallback =+    Maybe T.Text ->+    T.Text ->+    GVariant ->+    IO ()++noDBusProxyGSignalCallback :: Maybe DBusProxyGSignalCallback+noDBusProxyGSignalCallback = Nothing++type DBusProxyGSignalCallbackC =+    Ptr () ->                               -- object+    CString ->+    CString ->+    Ptr GVariant ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkDBusProxyGSignalCallback :: DBusProxyGSignalCallbackC -> IO (FunPtr DBusProxyGSignalCallbackC)++dBusProxyGSignalClosure :: DBusProxyGSignalCallback -> IO Closure+dBusProxyGSignalClosure cb = newCClosure =<< mkDBusProxyGSignalCallback wrapped+    where wrapped = dBusProxyGSignalCallbackWrapper cb++dBusProxyGSignalCallbackWrapper ::+    DBusProxyGSignalCallback ->+    Ptr () ->+    CString ->+    CString ->+    Ptr GVariant ->+    Ptr () ->+    IO ()+dBusProxyGSignalCallbackWrapper _cb _ sender_name signal_name parameters _ = do+    maybeSender_name <-+        if sender_name == nullPtr+        then return Nothing+        else do+            sender_name' <- cstringToText sender_name+            return $ Just sender_name'+    signal_name' <- cstringToText signal_name+    parameters' <- newGVariantFromPtr parameters+    _cb  maybeSender_name signal_name' parameters'++onDBusProxyGSignal :: (GObject a, MonadIO m) => a -> DBusProxyGSignalCallback -> m SignalHandlerId+onDBusProxyGSignal obj cb = liftIO $ connectDBusProxyGSignal obj cb SignalConnectBefore+afterDBusProxyGSignal :: (GObject a, MonadIO m) => a -> DBusProxyGSignalCallback -> m SignalHandlerId+afterDBusProxyGSignal obj cb = connectDBusProxyGSignal obj cb SignalConnectAfter++connectDBusProxyGSignal :: (GObject a, MonadIO m) =>+                           a -> DBusProxyGSignalCallback -> SignalConnectMode -> m SignalHandlerId+connectDBusProxyGSignal obj cb after = liftIO $ do+    cb' <- mkDBusProxyGSignalCallback (dBusProxyGSignalCallbackWrapper cb)+    connectSignalFunPtr obj "g-signal" cb' after++-- VVV Prop "g-bus-type"+   -- Type: TInterface "Gio" "BusType"+   -- Flags: [PropertyWritable,PropertyConstructOnly]++constructDBusProxyGBusType :: BusType -> IO ([Char], GValue)+constructDBusProxyGBusType val = constructObjectPropertyEnum "g-bus-type" val++data DBusProxyGBusTypePropertyInfo+instance AttrInfo DBusProxyGBusTypePropertyInfo where+    type AttrAllowedOps DBusProxyGBusTypePropertyInfo = '[ 'AttrConstruct]+    type AttrSetTypeConstraint DBusProxyGBusTypePropertyInfo = (~) BusType+    type AttrBaseTypeConstraint DBusProxyGBusTypePropertyInfo = DBusProxyK+    type AttrGetType DBusProxyGBusTypePropertyInfo = ()+    type AttrLabel DBusProxyGBusTypePropertyInfo = "DBusProxy::g-bus-type"+    attrGet _ = undefined+    attrSet _ = undefined+    attrConstruct _ = constructDBusProxyGBusType++-- VVV Prop "g-connection"+   -- Type: TInterface "Gio" "DBusConnection"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getDBusProxyGConnection :: (MonadIO m, DBusProxyK o) => o -> m DBusConnection+getDBusProxyGConnection obj = liftIO $ getObjectPropertyObject obj "g-connection" DBusConnection++constructDBusProxyGConnection :: (DBusConnectionK a) => a -> IO ([Char], GValue)+constructDBusProxyGConnection val = constructObjectPropertyObject "g-connection" val++data DBusProxyGConnectionPropertyInfo+instance AttrInfo DBusProxyGConnectionPropertyInfo where+    type AttrAllowedOps DBusProxyGConnectionPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DBusProxyGConnectionPropertyInfo = DBusConnectionK+    type AttrBaseTypeConstraint DBusProxyGConnectionPropertyInfo = DBusProxyK+    type AttrGetType DBusProxyGConnectionPropertyInfo = DBusConnection+    type AttrLabel DBusProxyGConnectionPropertyInfo = "DBusProxy::g-connection"+    attrGet _ = getDBusProxyGConnection+    attrSet _ = undefined+    attrConstruct _ = constructDBusProxyGConnection++-- VVV Prop "g-default-timeout"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getDBusProxyGDefaultTimeout :: (MonadIO m, DBusProxyK o) => o -> m Int32+getDBusProxyGDefaultTimeout obj = liftIO $ getObjectPropertyCInt obj "g-default-timeout"++setDBusProxyGDefaultTimeout :: (MonadIO m, DBusProxyK o) => o -> Int32 -> m ()+setDBusProxyGDefaultTimeout obj val = liftIO $ setObjectPropertyCInt obj "g-default-timeout" val++constructDBusProxyGDefaultTimeout :: Int32 -> IO ([Char], GValue)+constructDBusProxyGDefaultTimeout val = constructObjectPropertyCInt "g-default-timeout" val++data DBusProxyGDefaultTimeoutPropertyInfo+instance AttrInfo DBusProxyGDefaultTimeoutPropertyInfo where+    type AttrAllowedOps DBusProxyGDefaultTimeoutPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DBusProxyGDefaultTimeoutPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint DBusProxyGDefaultTimeoutPropertyInfo = DBusProxyK+    type AttrGetType DBusProxyGDefaultTimeoutPropertyInfo = Int32+    type AttrLabel DBusProxyGDefaultTimeoutPropertyInfo = "DBusProxy::g-default-timeout"+    attrGet _ = getDBusProxyGDefaultTimeout+    attrSet _ = setDBusProxyGDefaultTimeout+    attrConstruct _ = constructDBusProxyGDefaultTimeout++-- VVV Prop "g-flags"+   -- Type: TInterface "Gio" "DBusProxyFlags"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getDBusProxyGFlags :: (MonadIO m, DBusProxyK o) => o -> m [DBusProxyFlags]+getDBusProxyGFlags obj = liftIO $ getObjectPropertyFlags obj "g-flags"++constructDBusProxyGFlags :: [DBusProxyFlags] -> IO ([Char], GValue)+constructDBusProxyGFlags val = constructObjectPropertyFlags "g-flags" val++data DBusProxyGFlagsPropertyInfo+instance AttrInfo DBusProxyGFlagsPropertyInfo where+    type AttrAllowedOps DBusProxyGFlagsPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DBusProxyGFlagsPropertyInfo = (~) [DBusProxyFlags]+    type AttrBaseTypeConstraint DBusProxyGFlagsPropertyInfo = DBusProxyK+    type AttrGetType DBusProxyGFlagsPropertyInfo = [DBusProxyFlags]+    type AttrLabel DBusProxyGFlagsPropertyInfo = "DBusProxy::g-flags"+    attrGet _ = getDBusProxyGFlags+    attrSet _ = undefined+    attrConstruct _ = constructDBusProxyGFlags++-- VVV Prop "g-interface-info"+   -- Type: TInterface "Gio" "DBusInterfaceInfo"+   -- Flags: [PropertyReadable,PropertyWritable]++getDBusProxyGInterfaceInfo :: (MonadIO m, DBusProxyK o) => o -> m DBusInterfaceInfo+getDBusProxyGInterfaceInfo obj = liftIO $ getObjectPropertyBoxed obj "g-interface-info" DBusInterfaceInfo++setDBusProxyGInterfaceInfo :: (MonadIO m, DBusProxyK o) => o -> DBusInterfaceInfo -> m ()+setDBusProxyGInterfaceInfo obj val = liftIO $ setObjectPropertyBoxed obj "g-interface-info" val++constructDBusProxyGInterfaceInfo :: DBusInterfaceInfo -> IO ([Char], GValue)+constructDBusProxyGInterfaceInfo val = constructObjectPropertyBoxed "g-interface-info" val++data DBusProxyGInterfaceInfoPropertyInfo+instance AttrInfo DBusProxyGInterfaceInfoPropertyInfo where+    type AttrAllowedOps DBusProxyGInterfaceInfoPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DBusProxyGInterfaceInfoPropertyInfo = (~) DBusInterfaceInfo+    type AttrBaseTypeConstraint DBusProxyGInterfaceInfoPropertyInfo = DBusProxyK+    type AttrGetType DBusProxyGInterfaceInfoPropertyInfo = DBusInterfaceInfo+    type AttrLabel DBusProxyGInterfaceInfoPropertyInfo = "DBusProxy::g-interface-info"+    attrGet _ = getDBusProxyGInterfaceInfo+    attrSet _ = setDBusProxyGInterfaceInfo+    attrConstruct _ = constructDBusProxyGInterfaceInfo++-- VVV Prop "g-interface-name"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getDBusProxyGInterfaceName :: (MonadIO m, DBusProxyK o) => o -> m T.Text+getDBusProxyGInterfaceName obj = liftIO $ getObjectPropertyString obj "g-interface-name"++constructDBusProxyGInterfaceName :: T.Text -> IO ([Char], GValue)+constructDBusProxyGInterfaceName val = constructObjectPropertyString "g-interface-name" val++data DBusProxyGInterfaceNamePropertyInfo+instance AttrInfo DBusProxyGInterfaceNamePropertyInfo where+    type AttrAllowedOps DBusProxyGInterfaceNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DBusProxyGInterfaceNamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint DBusProxyGInterfaceNamePropertyInfo = DBusProxyK+    type AttrGetType DBusProxyGInterfaceNamePropertyInfo = T.Text+    type AttrLabel DBusProxyGInterfaceNamePropertyInfo = "DBusProxy::g-interface-name"+    attrGet _ = getDBusProxyGInterfaceName+    attrSet _ = undefined+    attrConstruct _ = constructDBusProxyGInterfaceName++-- VVV Prop "g-name"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getDBusProxyGName :: (MonadIO m, DBusProxyK o) => o -> m T.Text+getDBusProxyGName obj = liftIO $ getObjectPropertyString obj "g-name"++constructDBusProxyGName :: T.Text -> IO ([Char], GValue)+constructDBusProxyGName val = constructObjectPropertyString "g-name" val++data DBusProxyGNamePropertyInfo+instance AttrInfo DBusProxyGNamePropertyInfo where+    type AttrAllowedOps DBusProxyGNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DBusProxyGNamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint DBusProxyGNamePropertyInfo = DBusProxyK+    type AttrGetType DBusProxyGNamePropertyInfo = T.Text+    type AttrLabel DBusProxyGNamePropertyInfo = "DBusProxy::g-name"+    attrGet _ = getDBusProxyGName+    attrSet _ = undefined+    attrConstruct _ = constructDBusProxyGName++-- VVV Prop "g-name-owner"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable]++getDBusProxyGNameOwner :: (MonadIO m, DBusProxyK o) => o -> m T.Text+getDBusProxyGNameOwner obj = liftIO $ getObjectPropertyString obj "g-name-owner"++data DBusProxyGNameOwnerPropertyInfo+instance AttrInfo DBusProxyGNameOwnerPropertyInfo where+    type AttrAllowedOps DBusProxyGNameOwnerPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint DBusProxyGNameOwnerPropertyInfo = (~) ()+    type AttrBaseTypeConstraint DBusProxyGNameOwnerPropertyInfo = DBusProxyK+    type AttrGetType DBusProxyGNameOwnerPropertyInfo = T.Text+    type AttrLabel DBusProxyGNameOwnerPropertyInfo = "DBusProxy::g-name-owner"+    attrGet _ = getDBusProxyGNameOwner+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "g-object-path"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getDBusProxyGObjectPath :: (MonadIO m, DBusProxyK o) => o -> m T.Text+getDBusProxyGObjectPath obj = liftIO $ getObjectPropertyString obj "g-object-path"++constructDBusProxyGObjectPath :: T.Text -> IO ([Char], GValue)+constructDBusProxyGObjectPath val = constructObjectPropertyString "g-object-path" val++data DBusProxyGObjectPathPropertyInfo+instance AttrInfo DBusProxyGObjectPathPropertyInfo where+    type AttrAllowedOps DBusProxyGObjectPathPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DBusProxyGObjectPathPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint DBusProxyGObjectPathPropertyInfo = DBusProxyK+    type AttrGetType DBusProxyGObjectPathPropertyInfo = T.Text+    type AttrLabel DBusProxyGObjectPathPropertyInfo = "DBusProxy::g-object-path"+    attrGet _ = getDBusProxyGObjectPath+    attrSet _ = undefined+    attrConstruct _ = constructDBusProxyGObjectPath++type instance AttributeList DBusProxy = DBusProxyAttributeList+type DBusProxyAttributeList = ('[ '("g-bus-type", DBusProxyGBusTypePropertyInfo), '("g-connection", DBusProxyGConnectionPropertyInfo), '("g-default-timeout", DBusProxyGDefaultTimeoutPropertyInfo), '("g-flags", DBusProxyGFlagsPropertyInfo), '("g-interface-info", DBusProxyGInterfaceInfoPropertyInfo), '("g-interface-name", DBusProxyGInterfaceNamePropertyInfo), '("g-name", DBusProxyGNamePropertyInfo), '("g-name-owner", DBusProxyGNameOwnerPropertyInfo), '("g-object-path", DBusProxyGObjectPathPropertyInfo)] :: [(Symbol, *)])++data DBusProxyGPropertiesChangedSignalInfo+instance SignalInfo DBusProxyGPropertiesChangedSignalInfo where+    type HaskellCallbackType DBusProxyGPropertiesChangedSignalInfo = DBusProxyGPropertiesChangedCallback+    connectSignal _ = connectDBusProxyGPropertiesChanged++data DBusProxyGSignalSignalInfo+instance SignalInfo DBusProxyGSignalSignalInfo where+    type HaskellCallbackType DBusProxyGSignalSignalInfo = DBusProxyGSignalCallback+    connectSignal _ = connectDBusProxyGSignal++type instance SignalList DBusProxy = DBusProxySignalList+type DBusProxySignalList = ('[ '("g-properties-changed", DBusProxyGPropertiesChangedSignalInfo), '("g-signal", DBusProxyGSignalSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method DBusProxy::new_finish+-- method type : Constructor+-- Args : [Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusProxy"+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_proxy_new_finish" g_dbus_proxy_new_finish :: +    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr DBusProxy)+++dBusProxyNewFinish ::+    (MonadIO m, AsyncResultK a) =>+    a ->                                    -- res+    m DBusProxy+dBusProxyNewFinish res = liftIO $ do+    let res' = unsafeManagedPtrCastPtr res+    onException (do+        result <- propagateGError $ g_dbus_proxy_new_finish res'+        checkUnexpectedReturnNULL "g_dbus_proxy_new_finish" result+        result' <- (wrapObject DBusProxy) result+        touchManagedPtr res+        return result'+     ) (do+        return ()+     )++-- method DBusProxy::new_for_bus_finish+-- method type : Constructor+-- Args : [Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusProxy"+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_proxy_new_for_bus_finish" g_dbus_proxy_new_for_bus_finish :: +    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr DBusProxy)+++dBusProxyNewForBusFinish ::+    (MonadIO m, AsyncResultK a) =>+    a ->                                    -- res+    m DBusProxy+dBusProxyNewForBusFinish res = liftIO $ do+    let res' = unsafeManagedPtrCastPtr res+    onException (do+        result <- propagateGError $ g_dbus_proxy_new_for_bus_finish res'+        checkUnexpectedReturnNULL "g_dbus_proxy_new_for_bus_finish" result+        result' <- (wrapObject DBusProxy) result+        touchManagedPtr res+        return result'+     ) (do+        return ()+     )++-- method DBusProxy::new_for_bus_sync+-- method type : Constructor+-- Args : [Arg {argName = "bus_type", argType = TInterface "Gio" "BusType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusProxyFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "info", argType = TInterface "Gio" "DBusInterfaceInfo", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "bus_type", argType = TInterface "Gio" "BusType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusProxyFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "info", argType = TInterface "Gio" "DBusInterfaceInfo", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusProxy"+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_proxy_new_for_bus_sync" g_dbus_proxy_new_for_bus_sync :: +    CUInt ->                                -- bus_type : TInterface "Gio" "BusType"+    CUInt ->                                -- flags : TInterface "Gio" "DBusProxyFlags"+    Ptr DBusInterfaceInfo ->                -- info : TInterface "Gio" "DBusInterfaceInfo"+    CString ->                              -- name : TBasicType TUTF8+    CString ->                              -- object_path : TBasicType TUTF8+    CString ->                              -- interface_name : TBasicType TUTF8+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr DBusProxy)+++dBusProxyNewForBusSync ::+    (MonadIO m, CancellableK a) =>+    BusType ->                              -- bus_type+    [DBusProxyFlags] ->                     -- flags+    Maybe (DBusInterfaceInfo) ->            -- info+    T.Text ->                               -- name+    T.Text ->                               -- object_path+    T.Text ->                               -- interface_name+    Maybe (a) ->                            -- cancellable+    m DBusProxy+dBusProxyNewForBusSync bus_type flags info name object_path interface_name cancellable = liftIO $ do+    let bus_type' = (fromIntegral . fromEnum) bus_type+    let flags' = gflagsToWord flags+    maybeInfo <- case info of+        Nothing -> return nullPtr+        Just jInfo -> do+            let jInfo' = unsafeManagedPtrGetPtr jInfo+            return jInfo'+    name' <- textToCString name+    object_path' <- textToCString object_path+    interface_name' <- textToCString interface_name+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_dbus_proxy_new_for_bus_sync bus_type' flags' maybeInfo name' object_path' interface_name' maybeCancellable+        checkUnexpectedReturnNULL "g_dbus_proxy_new_for_bus_sync" result+        result' <- (wrapObject DBusProxy) result+        whenJust info touchManagedPtr+        whenJust cancellable touchManagedPtr+        freeMem name'+        freeMem object_path'+        freeMem interface_name'+        return result'+     ) (do+        freeMem name'+        freeMem object_path'+        freeMem interface_name'+     )++-- method DBusProxy::new_sync+-- method type : Constructor+-- Args : [Arg {argName = "connection", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusProxyFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "info", argType = TInterface "Gio" "DBusInterfaceInfo", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "connection", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusProxyFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "info", argType = TInterface "Gio" "DBusInterfaceInfo", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusProxy"+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_proxy_new_sync" g_dbus_proxy_new_sync :: +    Ptr DBusConnection ->                   -- connection : TInterface "Gio" "DBusConnection"+    CUInt ->                                -- flags : TInterface "Gio" "DBusProxyFlags"+    Ptr DBusInterfaceInfo ->                -- info : TInterface "Gio" "DBusInterfaceInfo"+    CString ->                              -- name : TBasicType TUTF8+    CString ->                              -- object_path : TBasicType TUTF8+    CString ->                              -- interface_name : TBasicType TUTF8+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr DBusProxy)+++dBusProxyNewSync ::+    (MonadIO m, DBusConnectionK a, CancellableK b) =>+    a ->                                    -- connection+    [DBusProxyFlags] ->                     -- flags+    Maybe (DBusInterfaceInfo) ->            -- info+    Maybe (T.Text) ->                       -- name+    T.Text ->                               -- object_path+    T.Text ->                               -- interface_name+    Maybe (b) ->                            -- cancellable+    m DBusProxy+dBusProxyNewSync connection flags info name object_path interface_name cancellable = liftIO $ do+    let connection' = unsafeManagedPtrCastPtr connection+    let flags' = gflagsToWord flags+    maybeInfo <- case info of+        Nothing -> return nullPtr+        Just jInfo -> do+            let jInfo' = unsafeManagedPtrGetPtr jInfo+            return jInfo'+    maybeName <- case name of+        Nothing -> return nullPtr+        Just jName -> do+            jName' <- textToCString jName+            return jName'+    object_path' <- textToCString object_path+    interface_name' <- textToCString interface_name+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_dbus_proxy_new_sync connection' flags' maybeInfo maybeName object_path' interface_name' maybeCancellable+        checkUnexpectedReturnNULL "g_dbus_proxy_new_sync" result+        result' <- (wrapObject DBusProxy) result+        touchManagedPtr connection+        whenJust info touchManagedPtr+        whenJust cancellable touchManagedPtr+        freeMem maybeName+        freeMem object_path'+        freeMem interface_name'+        return result'+     ) (do+        freeMem maybeName+        freeMem object_path'+        freeMem interface_name'+     )++-- method DBusProxy::call+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "method_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameters", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusCallFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "timeout_msec", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 7, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "method_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameters", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusCallFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "timeout_msec", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 7, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_proxy_call" g_dbus_proxy_call :: +    Ptr DBusProxy ->                        -- _obj : TInterface "Gio" "DBusProxy"+    CString ->                              -- method_name : TBasicType TUTF8+    Ptr GVariant ->                         -- parameters : TVariant+    CUInt ->                                -- flags : TInterface "Gio" "DBusCallFlags"+    Int32 ->                                -- timeout_msec : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++dBusProxyCall ::+    (MonadIO m, DBusProxyK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- method_name+    Maybe (GVariant) ->                     -- parameters+    [DBusCallFlags] ->                      -- flags+    Int32 ->                                -- timeout_msec+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+dBusProxyCall _obj method_name parameters flags timeout_msec cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    method_name' <- textToCString method_name+    maybeParameters <- case parameters of+        Nothing -> return nullPtr+        Just jParameters -> do+            let jParameters' = unsafeManagedPtrGetPtr jParameters+            return jParameters'+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_dbus_proxy_call _obj' method_name' maybeParameters flags' timeout_msec maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    freeMem method_name'+    return ()++-- method DBusProxy::call_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TVariant+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_proxy_call_finish" g_dbus_proxy_call_finish :: +    Ptr DBusProxy ->                        -- _obj : TInterface "Gio" "DBusProxy"+    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr GVariant)+++dBusProxyCallFinish ::+    (MonadIO m, DBusProxyK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- res+    m GVariant+dBusProxyCallFinish _obj res = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let res' = unsafeManagedPtrCastPtr res+    onException (do+        result <- propagateGError $ g_dbus_proxy_call_finish _obj' res'+        checkUnexpectedReturnNULL "g_dbus_proxy_call_finish" result+        result' <- wrapGVariantPtr result+        touchManagedPtr _obj+        touchManagedPtr res+        return result'+     ) (do+        return ()+     )++-- method DBusProxy::call_sync+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "method_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameters", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusCallFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "timeout_msec", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "method_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameters", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusCallFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "timeout_msec", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TVariant+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_proxy_call_sync" g_dbus_proxy_call_sync :: +    Ptr DBusProxy ->                        -- _obj : TInterface "Gio" "DBusProxy"+    CString ->                              -- method_name : TBasicType TUTF8+    Ptr GVariant ->                         -- parameters : TVariant+    CUInt ->                                -- flags : TInterface "Gio" "DBusCallFlags"+    Int32 ->                                -- timeout_msec : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr GVariant)+++dBusProxyCallSync ::+    (MonadIO m, DBusProxyK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- method_name+    Maybe (GVariant) ->                     -- parameters+    [DBusCallFlags] ->                      -- flags+    Int32 ->                                -- timeout_msec+    Maybe (b) ->                            -- cancellable+    m GVariant+dBusProxyCallSync _obj method_name parameters flags timeout_msec cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    method_name' <- textToCString method_name+    maybeParameters <- case parameters of+        Nothing -> return nullPtr+        Just jParameters -> do+            let jParameters' = unsafeManagedPtrGetPtr jParameters+            return jParameters'+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_dbus_proxy_call_sync _obj' method_name' maybeParameters flags' timeout_msec maybeCancellable+        checkUnexpectedReturnNULL "g_dbus_proxy_call_sync" result+        result' <- wrapGVariantPtr result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem method_name'+        return result'+     ) (do+        freeMem method_name'+     )++-- method DBusProxy::call_with_unix_fd_list+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "method_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameters", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusCallFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "timeout_msec", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fd_list", argType = TInterface "Gio" "UnixFDList", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 8, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "method_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameters", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusCallFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "timeout_msec", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fd_list", argType = TInterface "Gio" "UnixFDList", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 8, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_proxy_call_with_unix_fd_list" g_dbus_proxy_call_with_unix_fd_list :: +    Ptr DBusProxy ->                        -- _obj : TInterface "Gio" "DBusProxy"+    CString ->                              -- method_name : TBasicType TUTF8+    Ptr GVariant ->                         -- parameters : TVariant+    CUInt ->                                -- flags : TInterface "Gio" "DBusCallFlags"+    Int32 ->                                -- timeout_msec : TBasicType TInt32+    Ptr UnixFDList ->                       -- fd_list : TInterface "Gio" "UnixFDList"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++dBusProxyCallWithUnixFdList ::+    (MonadIO m, DBusProxyK a, UnixFDListK b, CancellableK c) =>+    a ->                                    -- _obj+    T.Text ->                               -- method_name+    Maybe (GVariant) ->                     -- parameters+    [DBusCallFlags] ->                      -- flags+    Int32 ->                                -- timeout_msec+    Maybe (b) ->                            -- fd_list+    Maybe (c) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+dBusProxyCallWithUnixFdList _obj method_name parameters flags timeout_msec fd_list cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    method_name' <- textToCString method_name+    maybeParameters <- case parameters of+        Nothing -> return nullPtr+        Just jParameters -> do+            let jParameters' = unsafeManagedPtrGetPtr jParameters+            return jParameters'+    let flags' = gflagsToWord flags+    maybeFd_list <- case fd_list of+        Nothing -> return nullPtr+        Just jFd_list -> do+            let jFd_list' = unsafeManagedPtrCastPtr jFd_list+            return jFd_list'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_dbus_proxy_call_with_unix_fd_list _obj' method_name' maybeParameters flags' timeout_msec maybeFd_list maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust fd_list touchManagedPtr+    whenJust cancellable touchManagedPtr+    freeMem method_name'+    return ()++-- method DBusProxy::call_with_unix_fd_list_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "out_fd_list", argType = TInterface "Gio" "UnixFDList", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "res", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TVariant+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_proxy_call_with_unix_fd_list_finish" g_dbus_proxy_call_with_unix_fd_list_finish :: +    Ptr DBusProxy ->                        -- _obj : TInterface "Gio" "DBusProxy"+    Ptr (Ptr UnixFDList) ->                 -- out_fd_list : TInterface "Gio" "UnixFDList"+    Ptr AsyncResult ->                      -- res : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr GVariant)+++dBusProxyCallWithUnixFdListFinish ::+    (MonadIO m, DBusProxyK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- res+    m (GVariant,UnixFDList)+dBusProxyCallWithUnixFdListFinish _obj res = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    out_fd_list <- allocMem :: IO (Ptr (Ptr UnixFDList))+    let res' = unsafeManagedPtrCastPtr res+    onException (do+        result <- propagateGError $ g_dbus_proxy_call_with_unix_fd_list_finish _obj' out_fd_list res'+        checkUnexpectedReturnNULL "g_dbus_proxy_call_with_unix_fd_list_finish" result+        result' <- wrapGVariantPtr result+        out_fd_list' <- peek out_fd_list+        out_fd_list'' <- (wrapObject UnixFDList) out_fd_list'+        touchManagedPtr _obj+        touchManagedPtr res+        freeMem out_fd_list+        return (result', out_fd_list'')+     ) (do+        freeMem out_fd_list+     )++-- method DBusProxy::call_with_unix_fd_list_sync+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "method_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameters", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusCallFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "timeout_msec", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fd_list", argType = TInterface "Gio" "UnixFDList", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "out_fd_list", argType = TInterface "Gio" "UnixFDList", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "method_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameters", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusCallFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "timeout_msec", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fd_list", argType = TInterface "Gio" "UnixFDList", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TVariant+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_proxy_call_with_unix_fd_list_sync" g_dbus_proxy_call_with_unix_fd_list_sync :: +    Ptr DBusProxy ->                        -- _obj : TInterface "Gio" "DBusProxy"+    CString ->                              -- method_name : TBasicType TUTF8+    Ptr GVariant ->                         -- parameters : TVariant+    CUInt ->                                -- flags : TInterface "Gio" "DBusCallFlags"+    Int32 ->                                -- timeout_msec : TBasicType TInt32+    Ptr UnixFDList ->                       -- fd_list : TInterface "Gio" "UnixFDList"+    Ptr (Ptr UnixFDList) ->                 -- out_fd_list : TInterface "Gio" "UnixFDList"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr GVariant)+++dBusProxyCallWithUnixFdListSync ::+    (MonadIO m, DBusProxyK a, UnixFDListK b, CancellableK c) =>+    a ->                                    -- _obj+    T.Text ->                               -- method_name+    Maybe (GVariant) ->                     -- parameters+    [DBusCallFlags] ->                      -- flags+    Int32 ->                                -- timeout_msec+    Maybe (b) ->                            -- fd_list+    Maybe (c) ->                            -- cancellable+    m (GVariant,UnixFDList)+dBusProxyCallWithUnixFdListSync _obj method_name parameters flags timeout_msec fd_list cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    method_name' <- textToCString method_name+    maybeParameters <- case parameters of+        Nothing -> return nullPtr+        Just jParameters -> do+            let jParameters' = unsafeManagedPtrGetPtr jParameters+            return jParameters'+    let flags' = gflagsToWord flags+    maybeFd_list <- case fd_list of+        Nothing -> return nullPtr+        Just jFd_list -> do+            let jFd_list' = unsafeManagedPtrCastPtr jFd_list+            return jFd_list'+    out_fd_list <- allocMem :: IO (Ptr (Ptr UnixFDList))+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_dbus_proxy_call_with_unix_fd_list_sync _obj' method_name' maybeParameters flags' timeout_msec maybeFd_list out_fd_list maybeCancellable+        checkUnexpectedReturnNULL "g_dbus_proxy_call_with_unix_fd_list_sync" result+        result' <- wrapGVariantPtr result+        out_fd_list' <- peek out_fd_list+        out_fd_list'' <- (wrapObject UnixFDList) out_fd_list'+        touchManagedPtr _obj+        whenJust fd_list touchManagedPtr+        whenJust cancellable touchManagedPtr+        freeMem method_name'+        freeMem out_fd_list+        return (result', out_fd_list'')+     ) (do+        freeMem method_name'+        freeMem out_fd_list+     )++-- method DBusProxy::get_cached_property+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "property_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "property_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TVariant+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_proxy_get_cached_property" g_dbus_proxy_get_cached_property :: +    Ptr DBusProxy ->                        -- _obj : TInterface "Gio" "DBusProxy"+    CString ->                              -- property_name : TBasicType TUTF8+    IO (Ptr GVariant)+++dBusProxyGetCachedProperty ::+    (MonadIO m, DBusProxyK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- property_name+    m GVariant+dBusProxyGetCachedProperty _obj property_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    property_name' <- textToCString property_name+    result <- g_dbus_proxy_get_cached_property _obj' property_name'+    checkUnexpectedReturnNULL "g_dbus_proxy_get_cached_property" result+    result' <- wrapGVariantPtr result+    touchManagedPtr _obj+    freeMem property_name'+    return result'++-- method DBusProxy::get_cached_property_names+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_proxy_get_cached_property_names" g_dbus_proxy_get_cached_property_names :: +    Ptr DBusProxy ->                        -- _obj : TInterface "Gio" "DBusProxy"+    IO (Ptr CString)+++dBusProxyGetCachedPropertyNames ::+    (MonadIO m, DBusProxyK a) =>+    a ->                                    -- _obj+    m [T.Text]+dBusProxyGetCachedPropertyNames _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_proxy_get_cached_property_names _obj'+    checkUnexpectedReturnNULL "g_dbus_proxy_get_cached_property_names" result+    result' <- unpackZeroTerminatedUTF8CArray result+    mapZeroTerminatedCArray freeMem result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method DBusProxy::get_connection+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusConnection"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_proxy_get_connection" g_dbus_proxy_get_connection :: +    Ptr DBusProxy ->                        -- _obj : TInterface "Gio" "DBusProxy"+    IO (Ptr DBusConnection)+++dBusProxyGetConnection ::+    (MonadIO m, DBusProxyK a) =>+    a ->                                    -- _obj+    m DBusConnection+dBusProxyGetConnection _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_proxy_get_connection _obj'+    checkUnexpectedReturnNULL "g_dbus_proxy_get_connection" result+    result' <- (newObject DBusConnection) result+    touchManagedPtr _obj+    return result'++-- method DBusProxy::get_default_timeout+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_proxy_get_default_timeout" g_dbus_proxy_get_default_timeout :: +    Ptr DBusProxy ->                        -- _obj : TInterface "Gio" "DBusProxy"+    IO Int32+++dBusProxyGetDefaultTimeout ::+    (MonadIO m, DBusProxyK a) =>+    a ->                                    -- _obj+    m Int32+dBusProxyGetDefaultTimeout _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_proxy_get_default_timeout _obj'+    touchManagedPtr _obj+    return result++-- method DBusProxy::get_flags+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusProxyFlags"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_proxy_get_flags" g_dbus_proxy_get_flags :: +    Ptr DBusProxy ->                        -- _obj : TInterface "Gio" "DBusProxy"+    IO CUInt+++dBusProxyGetFlags ::+    (MonadIO m, DBusProxyK a) =>+    a ->                                    -- _obj+    m [DBusProxyFlags]+dBusProxyGetFlags _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_proxy_get_flags _obj'+    let result' = wordToGFlags result+    touchManagedPtr _obj+    return result'++-- method DBusProxy::get_interface_info+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusInterfaceInfo"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_proxy_get_interface_info" g_dbus_proxy_get_interface_info :: +    Ptr DBusProxy ->                        -- _obj : TInterface "Gio" "DBusProxy"+    IO (Ptr DBusInterfaceInfo)+++dBusProxyGetInterfaceInfo ::+    (MonadIO m, DBusProxyK a) =>+    a ->                                    -- _obj+    m DBusInterfaceInfo+dBusProxyGetInterfaceInfo _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_proxy_get_interface_info _obj'+    checkUnexpectedReturnNULL "g_dbus_proxy_get_interface_info" result+    result' <- (wrapBoxed DBusInterfaceInfo) result+    touchManagedPtr _obj+    return result'++-- method DBusProxy::get_interface_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_proxy_get_interface_name" g_dbus_proxy_get_interface_name :: +    Ptr DBusProxy ->                        -- _obj : TInterface "Gio" "DBusProxy"+    IO CString+++dBusProxyGetInterfaceName ::+    (MonadIO m, DBusProxyK a) =>+    a ->                                    -- _obj+    m T.Text+dBusProxyGetInterfaceName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_proxy_get_interface_name _obj'+    checkUnexpectedReturnNULL "g_dbus_proxy_get_interface_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method DBusProxy::get_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_proxy_get_name" g_dbus_proxy_get_name :: +    Ptr DBusProxy ->                        -- _obj : TInterface "Gio" "DBusProxy"+    IO CString+++dBusProxyGetName ::+    (MonadIO m, DBusProxyK a) =>+    a ->                                    -- _obj+    m T.Text+dBusProxyGetName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_proxy_get_name _obj'+    checkUnexpectedReturnNULL "g_dbus_proxy_get_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method DBusProxy::get_name_owner+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_proxy_get_name_owner" g_dbus_proxy_get_name_owner :: +    Ptr DBusProxy ->                        -- _obj : TInterface "Gio" "DBusProxy"+    IO CString+++dBusProxyGetNameOwner ::+    (MonadIO m, DBusProxyK a) =>+    a ->                                    -- _obj+    m T.Text+dBusProxyGetNameOwner _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_proxy_get_name_owner _obj'+    checkUnexpectedReturnNULL "g_dbus_proxy_get_name_owner" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method DBusProxy::get_object_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_proxy_get_object_path" g_dbus_proxy_get_object_path :: +    Ptr DBusProxy ->                        -- _obj : TInterface "Gio" "DBusProxy"+    IO CString+++dBusProxyGetObjectPath ::+    (MonadIO m, DBusProxyK a) =>+    a ->                                    -- _obj+    m T.Text+dBusProxyGetObjectPath _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_proxy_get_object_path _obj'+    checkUnexpectedReturnNULL "g_dbus_proxy_get_object_path" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method DBusProxy::set_cached_property+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "property_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "property_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_proxy_set_cached_property" g_dbus_proxy_set_cached_property :: +    Ptr DBusProxy ->                        -- _obj : TInterface "Gio" "DBusProxy"+    CString ->                              -- property_name : TBasicType TUTF8+    Ptr GVariant ->                         -- value : TVariant+    IO ()+++dBusProxySetCachedProperty ::+    (MonadIO m, DBusProxyK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- property_name+    Maybe (GVariant) ->                     -- value+    m ()+dBusProxySetCachedProperty _obj property_name value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    property_name' <- textToCString property_name+    maybeValue <- case value of+        Nothing -> return nullPtr+        Just jValue -> do+            let jValue' = unsafeManagedPtrGetPtr jValue+            return jValue'+    g_dbus_proxy_set_cached_property _obj' property_name' maybeValue+    touchManagedPtr _obj+    freeMem property_name'+    return ()++-- method DBusProxy::set_default_timeout+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "timeout_msec", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "timeout_msec", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_proxy_set_default_timeout" g_dbus_proxy_set_default_timeout :: +    Ptr DBusProxy ->                        -- _obj : TInterface "Gio" "DBusProxy"+    Int32 ->                                -- timeout_msec : TBasicType TInt32+    IO ()+++dBusProxySetDefaultTimeout ::+    (MonadIO m, DBusProxyK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- timeout_msec+    m ()+dBusProxySetDefaultTimeout _obj timeout_msec = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_dbus_proxy_set_default_timeout _obj' timeout_msec+    touchManagedPtr _obj+    return ()++-- method DBusProxy::set_interface_info+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "info", argType = TInterface "Gio" "DBusInterfaceInfo", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "info", argType = TInterface "Gio" "DBusInterfaceInfo", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_proxy_set_interface_info" g_dbus_proxy_set_interface_info :: +    Ptr DBusProxy ->                        -- _obj : TInterface "Gio" "DBusProxy"+    Ptr DBusInterfaceInfo ->                -- info : TInterface "Gio" "DBusInterfaceInfo"+    IO ()+++dBusProxySetInterfaceInfo ::+    (MonadIO m, DBusProxyK a) =>+    a ->                                    -- _obj+    Maybe (DBusInterfaceInfo) ->            -- info+    m ()+dBusProxySetInterfaceInfo _obj info = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeInfo <- case info of+        Nothing -> return nullPtr+        Just jInfo -> do+            let jInfo' = unsafeManagedPtrGetPtr jInfo+            return jInfo'+    g_dbus_proxy_set_interface_info _obj' maybeInfo+    touchManagedPtr _obj+    whenJust info touchManagedPtr+    return ()++-- method DBusProxy::new+-- method type : MemberFunction+-- Args : [Arg {argName = "connection", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusProxyFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "info", argType = TInterface "Gio" "DBusInterfaceInfo", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 8, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "connection", argType = TInterface "Gio" "DBusConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusProxyFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "info", argType = TInterface "Gio" "DBusInterfaceInfo", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 8, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_proxy_new" g_dbus_proxy_new :: +    Ptr DBusConnection ->                   -- connection : TInterface "Gio" "DBusConnection"+    CUInt ->                                -- flags : TInterface "Gio" "DBusProxyFlags"+    Ptr DBusInterfaceInfo ->                -- info : TInterface "Gio" "DBusInterfaceInfo"+    CString ->                              -- name : TBasicType TUTF8+    CString ->                              -- object_path : TBasicType TUTF8+    CString ->                              -- interface_name : TBasicType TUTF8+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++dBusProxyNew ::+    (MonadIO m, DBusConnectionK a, CancellableK b) =>+    a ->                                    -- connection+    [DBusProxyFlags] ->                     -- flags+    Maybe (DBusInterfaceInfo) ->            -- info+    Maybe (T.Text) ->                       -- name+    T.Text ->                               -- object_path+    T.Text ->                               -- interface_name+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+dBusProxyNew connection flags info name object_path interface_name cancellable callback = liftIO $ do+    let connection' = unsafeManagedPtrCastPtr connection+    let flags' = gflagsToWord flags+    maybeInfo <- case info of+        Nothing -> return nullPtr+        Just jInfo -> do+            let jInfo' = unsafeManagedPtrGetPtr jInfo+            return jInfo'+    maybeName <- case name of+        Nothing -> return nullPtr+        Just jName -> do+            jName' <- textToCString jName+            return jName'+    object_path' <- textToCString object_path+    interface_name' <- textToCString interface_name+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_dbus_proxy_new connection' flags' maybeInfo maybeName object_path' interface_name' maybeCancellable maybeCallback user_data+    touchManagedPtr connection+    whenJust info touchManagedPtr+    whenJust cancellable touchManagedPtr+    freeMem maybeName+    freeMem object_path'+    freeMem interface_name'+    return ()++-- method DBusProxy::new_for_bus+-- method type : MemberFunction+-- Args : [Arg {argName = "bus_type", argType = TInterface "Gio" "BusType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusProxyFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "info", argType = TInterface "Gio" "DBusInterfaceInfo", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 8, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "bus_type", argType = TInterface "Gio" "BusType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusProxyFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "info", argType = TInterface "Gio" "DBusInterfaceInfo", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interface_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 8, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_proxy_new_for_bus" g_dbus_proxy_new_for_bus :: +    CUInt ->                                -- bus_type : TInterface "Gio" "BusType"+    CUInt ->                                -- flags : TInterface "Gio" "DBusProxyFlags"+    Ptr DBusInterfaceInfo ->                -- info : TInterface "Gio" "DBusInterfaceInfo"+    CString ->                              -- name : TBasicType TUTF8+    CString ->                              -- object_path : TBasicType TUTF8+    CString ->                              -- interface_name : TBasicType TUTF8+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++dBusProxyNewForBus ::+    (MonadIO m, CancellableK a) =>+    BusType ->                              -- bus_type+    [DBusProxyFlags] ->                     -- flags+    Maybe (DBusInterfaceInfo) ->            -- info+    T.Text ->                               -- name+    T.Text ->                               -- object_path+    T.Text ->                               -- interface_name+    Maybe (a) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+dBusProxyNewForBus bus_type flags info name object_path interface_name cancellable callback = liftIO $ do+    let bus_type' = (fromIntegral . fromEnum) bus_type+    let flags' = gflagsToWord flags+    maybeInfo <- case info of+        Nothing -> return nullPtr+        Just jInfo -> do+            let jInfo' = unsafeManagedPtrGetPtr jInfo+            return jInfo'+    name' <- textToCString name+    object_path' <- textToCString object_path+    interface_name' <- textToCString interface_name+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_dbus_proxy_new_for_bus bus_type' flags' maybeInfo name' object_path' interface_name' maybeCancellable maybeCallback user_data+    whenJust info touchManagedPtr+    whenJust cancellable touchManagedPtr+    freeMem name'+    freeMem object_path'+    freeMem interface_name'+    return ()++
+ GI/Gio/Objects/DBusProxy.hs-boot view
@@ -0,0 +1,24 @@+module GI.Gio.Objects.DBusProxy where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype DBusProxy = DBusProxy (ForeignPtr DBusProxy)+instance GObject DBusProxy where+class GObject o => DBusProxyK o+instance (GObject o, IsDescendantOf DBusProxy o) => DBusProxyK o+data DBusProxyGBusTypePropertyInfo+data DBusProxyGConnectionPropertyInfo+data DBusProxyGDefaultTimeoutPropertyInfo+data DBusProxyGFlagsPropertyInfo+data DBusProxyGInterfaceInfoPropertyInfo+data DBusProxyGInterfaceNamePropertyInfo+data DBusProxyGNamePropertyInfo+data DBusProxyGNameOwnerPropertyInfo+data DBusProxyGObjectPathPropertyInfo+data DBusProxyGPropertiesChangedSignalInfo+data DBusProxyGSignalSignalInfo
+ GI/Gio/Objects/DBusServer.hs view
@@ -0,0 +1,515 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.DBusServer+    ( ++-- * Exported types+    DBusServer(..)                          ,+    DBusServerK                             ,+    toDBusServer                            ,+    noDBusServer                            ,+++ -- * Methods+-- ** dBusServerGetClientAddress+    dBusServerGetClientAddress              ,+++-- ** dBusServerGetFlags+    dBusServerGetFlags                      ,+++-- ** dBusServerGetGuid+    dBusServerGetGuid                       ,+++-- ** dBusServerIsActive+    dBusServerIsActive                      ,+++-- ** dBusServerNewSync+    dBusServerNewSync                       ,+++-- ** dBusServerStart+    dBusServerStart                         ,+++-- ** dBusServerStop+    dBusServerStop                          ,+++++ -- * Properties+-- ** Active+    DBusServerActivePropertyInfo            ,+    getDBusServerActive                     ,+++-- ** Address+    DBusServerAddressPropertyInfo           ,+    constructDBusServerAddress              ,+    getDBusServerAddress                    ,+++-- ** AuthenticationObserver+    DBusServerAuthenticationObserverPropertyInfo,+    constructDBusServerAuthenticationObserver,+    getDBusServerAuthenticationObserver     ,+++-- ** ClientAddress+    DBusServerClientAddressPropertyInfo     ,+    getDBusServerClientAddress              ,+++-- ** Flags+    DBusServerFlagsPropertyInfo             ,+    constructDBusServerFlags                ,+    getDBusServerFlags                      ,+++-- ** Guid+    DBusServerGuidPropertyInfo              ,+    constructDBusServerGuid                 ,+    getDBusServerGuid                       ,+++++ -- * Signals+-- ** NewConnection+    DBusServerNewConnectionCallback         ,+    DBusServerNewConnectionCallbackC        ,+    DBusServerNewConnectionSignalInfo       ,+    afterDBusServerNewConnection            ,+    dBusServerNewConnectionCallbackWrapper  ,+    dBusServerNewConnectionClosure          ,+    mkDBusServerNewConnectionCallback       ,+    noDBusServerNewConnectionCallback       ,+    onDBusServerNewConnection               ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype DBusServer = DBusServer (ForeignPtr DBusServer)+foreign import ccall "g_dbus_server_get_type"+    c_g_dbus_server_get_type :: IO GType++type instance ParentTypes DBusServer = DBusServerParentTypes+type DBusServerParentTypes = '[GObject.Object, Initable]++instance GObject DBusServer where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_dbus_server_get_type+    ++class GObject o => DBusServerK o+instance (GObject o, IsDescendantOf DBusServer o) => DBusServerK o++toDBusServer :: DBusServerK o => o -> IO DBusServer+toDBusServer = unsafeCastTo DBusServer++noDBusServer :: Maybe DBusServer+noDBusServer = Nothing++-- signal DBusServer::new-connection+type DBusServerNewConnectionCallback =+    DBusConnection ->+    IO Bool++noDBusServerNewConnectionCallback :: Maybe DBusServerNewConnectionCallback+noDBusServerNewConnectionCallback = Nothing++type DBusServerNewConnectionCallbackC =+    Ptr () ->                               -- object+    Ptr DBusConnection ->+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkDBusServerNewConnectionCallback :: DBusServerNewConnectionCallbackC -> IO (FunPtr DBusServerNewConnectionCallbackC)++dBusServerNewConnectionClosure :: DBusServerNewConnectionCallback -> IO Closure+dBusServerNewConnectionClosure cb = newCClosure =<< mkDBusServerNewConnectionCallback wrapped+    where wrapped = dBusServerNewConnectionCallbackWrapper cb++dBusServerNewConnectionCallbackWrapper ::+    DBusServerNewConnectionCallback ->+    Ptr () ->+    Ptr DBusConnection ->+    Ptr () ->+    IO CInt+dBusServerNewConnectionCallbackWrapper _cb _ connection _ = do+    connection' <- (newObject DBusConnection) connection+    result <- _cb  connection'+    let result' = (fromIntegral . fromEnum) result+    return result'++onDBusServerNewConnection :: (GObject a, MonadIO m) => a -> DBusServerNewConnectionCallback -> m SignalHandlerId+onDBusServerNewConnection obj cb = liftIO $ connectDBusServerNewConnection obj cb SignalConnectBefore+afterDBusServerNewConnection :: (GObject a, MonadIO m) => a -> DBusServerNewConnectionCallback -> m SignalHandlerId+afterDBusServerNewConnection obj cb = connectDBusServerNewConnection obj cb SignalConnectAfter++connectDBusServerNewConnection :: (GObject a, MonadIO m) =>+                                  a -> DBusServerNewConnectionCallback -> SignalConnectMode -> m SignalHandlerId+connectDBusServerNewConnection obj cb after = liftIO $ do+    cb' <- mkDBusServerNewConnectionCallback (dBusServerNewConnectionCallbackWrapper cb)+    connectSignalFunPtr obj "new-connection" cb' after++-- VVV Prop "active"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getDBusServerActive :: (MonadIO m, DBusServerK o) => o -> m Bool+getDBusServerActive obj = liftIO $ getObjectPropertyBool obj "active"++data DBusServerActivePropertyInfo+instance AttrInfo DBusServerActivePropertyInfo where+    type AttrAllowedOps DBusServerActivePropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint DBusServerActivePropertyInfo = (~) ()+    type AttrBaseTypeConstraint DBusServerActivePropertyInfo = DBusServerK+    type AttrGetType DBusServerActivePropertyInfo = Bool+    type AttrLabel DBusServerActivePropertyInfo = "DBusServer::active"+    attrGet _ = getDBusServerActive+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "address"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getDBusServerAddress :: (MonadIO m, DBusServerK o) => o -> m T.Text+getDBusServerAddress obj = liftIO $ getObjectPropertyString obj "address"++constructDBusServerAddress :: T.Text -> IO ([Char], GValue)+constructDBusServerAddress val = constructObjectPropertyString "address" val++data DBusServerAddressPropertyInfo+instance AttrInfo DBusServerAddressPropertyInfo where+    type AttrAllowedOps DBusServerAddressPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DBusServerAddressPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint DBusServerAddressPropertyInfo = DBusServerK+    type AttrGetType DBusServerAddressPropertyInfo = T.Text+    type AttrLabel DBusServerAddressPropertyInfo = "DBusServer::address"+    attrGet _ = getDBusServerAddress+    attrSet _ = undefined+    attrConstruct _ = constructDBusServerAddress++-- VVV Prop "authentication-observer"+   -- Type: TInterface "Gio" "DBusAuthObserver"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getDBusServerAuthenticationObserver :: (MonadIO m, DBusServerK o) => o -> m DBusAuthObserver+getDBusServerAuthenticationObserver obj = liftIO $ getObjectPropertyObject obj "authentication-observer" DBusAuthObserver++constructDBusServerAuthenticationObserver :: (DBusAuthObserverK a) => a -> IO ([Char], GValue)+constructDBusServerAuthenticationObserver val = constructObjectPropertyObject "authentication-observer" val++data DBusServerAuthenticationObserverPropertyInfo+instance AttrInfo DBusServerAuthenticationObserverPropertyInfo where+    type AttrAllowedOps DBusServerAuthenticationObserverPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DBusServerAuthenticationObserverPropertyInfo = DBusAuthObserverK+    type AttrBaseTypeConstraint DBusServerAuthenticationObserverPropertyInfo = DBusServerK+    type AttrGetType DBusServerAuthenticationObserverPropertyInfo = DBusAuthObserver+    type AttrLabel DBusServerAuthenticationObserverPropertyInfo = "DBusServer::authentication-observer"+    attrGet _ = getDBusServerAuthenticationObserver+    attrSet _ = undefined+    attrConstruct _ = constructDBusServerAuthenticationObserver++-- VVV Prop "client-address"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable]++getDBusServerClientAddress :: (MonadIO m, DBusServerK o) => o -> m T.Text+getDBusServerClientAddress obj = liftIO $ getObjectPropertyString obj "client-address"++data DBusServerClientAddressPropertyInfo+instance AttrInfo DBusServerClientAddressPropertyInfo where+    type AttrAllowedOps DBusServerClientAddressPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint DBusServerClientAddressPropertyInfo = (~) ()+    type AttrBaseTypeConstraint DBusServerClientAddressPropertyInfo = DBusServerK+    type AttrGetType DBusServerClientAddressPropertyInfo = T.Text+    type AttrLabel DBusServerClientAddressPropertyInfo = "DBusServer::client-address"+    attrGet _ = getDBusServerClientAddress+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "flags"+   -- Type: TInterface "Gio" "DBusServerFlags"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getDBusServerFlags :: (MonadIO m, DBusServerK o) => o -> m [DBusServerFlags]+getDBusServerFlags obj = liftIO $ getObjectPropertyFlags obj "flags"++constructDBusServerFlags :: [DBusServerFlags] -> IO ([Char], GValue)+constructDBusServerFlags val = constructObjectPropertyFlags "flags" val++data DBusServerFlagsPropertyInfo+instance AttrInfo DBusServerFlagsPropertyInfo where+    type AttrAllowedOps DBusServerFlagsPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DBusServerFlagsPropertyInfo = (~) [DBusServerFlags]+    type AttrBaseTypeConstraint DBusServerFlagsPropertyInfo = DBusServerK+    type AttrGetType DBusServerFlagsPropertyInfo = [DBusServerFlags]+    type AttrLabel DBusServerFlagsPropertyInfo = "DBusServer::flags"+    attrGet _ = getDBusServerFlags+    attrSet _ = undefined+    attrConstruct _ = constructDBusServerFlags++-- VVV Prop "guid"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getDBusServerGuid :: (MonadIO m, DBusServerK o) => o -> m T.Text+getDBusServerGuid obj = liftIO $ getObjectPropertyString obj "guid"++constructDBusServerGuid :: T.Text -> IO ([Char], GValue)+constructDBusServerGuid val = constructObjectPropertyString "guid" val++data DBusServerGuidPropertyInfo+instance AttrInfo DBusServerGuidPropertyInfo where+    type AttrAllowedOps DBusServerGuidPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DBusServerGuidPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint DBusServerGuidPropertyInfo = DBusServerK+    type AttrGetType DBusServerGuidPropertyInfo = T.Text+    type AttrLabel DBusServerGuidPropertyInfo = "DBusServer::guid"+    attrGet _ = getDBusServerGuid+    attrSet _ = undefined+    attrConstruct _ = constructDBusServerGuid++type instance AttributeList DBusServer = DBusServerAttributeList+type DBusServerAttributeList = ('[ '("active", DBusServerActivePropertyInfo), '("address", DBusServerAddressPropertyInfo), '("authentication-observer", DBusServerAuthenticationObserverPropertyInfo), '("client-address", DBusServerClientAddressPropertyInfo), '("flags", DBusServerFlagsPropertyInfo), '("guid", DBusServerGuidPropertyInfo)] :: [(Symbol, *)])++data DBusServerNewConnectionSignalInfo+instance SignalInfo DBusServerNewConnectionSignalInfo where+    type HaskellCallbackType DBusServerNewConnectionSignalInfo = DBusServerNewConnectionCallback+    connectSignal _ = connectDBusServerNewConnection++type instance SignalList DBusServer = DBusServerSignalList+type DBusServerSignalList = ('[ '("new-connection", DBusServerNewConnectionSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method DBusServer::new_sync+-- method type : Constructor+-- Args : [Arg {argName = "address", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusServerFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "guid", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "observer", argType = TInterface "Gio" "DBusAuthObserver", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "address", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "DBusServerFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "guid", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "observer", argType = TInterface "Gio" "DBusAuthObserver", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusServer"+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_server_new_sync" g_dbus_server_new_sync :: +    CString ->                              -- address : TBasicType TUTF8+    CUInt ->                                -- flags : TInterface "Gio" "DBusServerFlags"+    CString ->                              -- guid : TBasicType TUTF8+    Ptr DBusAuthObserver ->                 -- observer : TInterface "Gio" "DBusAuthObserver"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr DBusServer)+++dBusServerNewSync ::+    (MonadIO m, DBusAuthObserverK a, CancellableK b) =>+    T.Text ->                               -- address+    [DBusServerFlags] ->                    -- flags+    T.Text ->                               -- guid+    Maybe (a) ->                            -- observer+    Maybe (b) ->                            -- cancellable+    m DBusServer+dBusServerNewSync address flags guid observer cancellable = liftIO $ do+    address' <- textToCString address+    let flags' = gflagsToWord flags+    guid' <- textToCString guid+    maybeObserver <- case observer of+        Nothing -> return nullPtr+        Just jObserver -> do+            let jObserver' = unsafeManagedPtrCastPtr jObserver+            return jObserver'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_dbus_server_new_sync address' flags' guid' maybeObserver maybeCancellable+        checkUnexpectedReturnNULL "g_dbus_server_new_sync" result+        result' <- (wrapObject DBusServer) result+        whenJust observer touchManagedPtr+        whenJust cancellable touchManagedPtr+        freeMem address'+        freeMem guid'+        return result'+     ) (do+        freeMem address'+        freeMem guid'+     )++-- method DBusServer::get_client_address+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusServer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusServer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_server_get_client_address" g_dbus_server_get_client_address :: +    Ptr DBusServer ->                       -- _obj : TInterface "Gio" "DBusServer"+    IO CString+++dBusServerGetClientAddress ::+    (MonadIO m, DBusServerK a) =>+    a ->                                    -- _obj+    m T.Text+dBusServerGetClientAddress _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_server_get_client_address _obj'+    checkUnexpectedReturnNULL "g_dbus_server_get_client_address" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method DBusServer::get_flags+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusServer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusServer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusServerFlags"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_server_get_flags" g_dbus_server_get_flags :: +    Ptr DBusServer ->                       -- _obj : TInterface "Gio" "DBusServer"+    IO CUInt+++dBusServerGetFlags ::+    (MonadIO m, DBusServerK a) =>+    a ->                                    -- _obj+    m [DBusServerFlags]+dBusServerGetFlags _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_server_get_flags _obj'+    let result' = wordToGFlags result+    touchManagedPtr _obj+    return result'++-- method DBusServer::get_guid+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusServer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusServer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_server_get_guid" g_dbus_server_get_guid :: +    Ptr DBusServer ->                       -- _obj : TInterface "Gio" "DBusServer"+    IO CString+++dBusServerGetGuid ::+    (MonadIO m, DBusServerK a) =>+    a ->                                    -- _obj+    m T.Text+dBusServerGetGuid _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_server_get_guid _obj'+    checkUnexpectedReturnNULL "g_dbus_server_get_guid" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method DBusServer::is_active+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusServer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusServer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_server_is_active" g_dbus_server_is_active :: +    Ptr DBusServer ->                       -- _obj : TInterface "Gio" "DBusServer"+    IO CInt+++dBusServerIsActive ::+    (MonadIO m, DBusServerK a) =>+    a ->                                    -- _obj+    m Bool+dBusServerIsActive _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_dbus_server_is_active _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method DBusServer::start+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusServer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusServer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_server_start" g_dbus_server_start :: +    Ptr DBusServer ->                       -- _obj : TInterface "Gio" "DBusServer"+    IO ()+++dBusServerStart ::+    (MonadIO m, DBusServerK a) =>+    a ->                                    -- _obj+    m ()+dBusServerStart _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_dbus_server_start _obj'+    touchManagedPtr _obj+    return ()++-- method DBusServer::stop+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusServer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusServer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_server_stop" g_dbus_server_stop :: +    Ptr DBusServer ->                       -- _obj : TInterface "Gio" "DBusServer"+    IO ()+++dBusServerStop ::+    (MonadIO m, DBusServerK a) =>+    a ->                                    -- _obj+    m ()+dBusServerStop _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_dbus_server_stop _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Objects/DBusServer.hs-boot view
@@ -0,0 +1,20 @@+module GI.Gio.Objects.DBusServer where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype DBusServer = DBusServer (ForeignPtr DBusServer)+instance GObject DBusServer where+class GObject o => DBusServerK o+instance (GObject o, IsDescendantOf DBusServer o) => DBusServerK o+data DBusServerActivePropertyInfo+data DBusServerAddressPropertyInfo+data DBusServerAuthenticationObserverPropertyInfo+data DBusServerClientAddressPropertyInfo+data DBusServerFlagsPropertyInfo+data DBusServerGuidPropertyInfo+data DBusServerNewConnectionSignalInfo
+ GI/Gio/Objects/DataInputStream.hs view
@@ -0,0 +1,1100 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.DataInputStream+    ( ++-- * Exported types+    DataInputStream(..)                     ,+    DataInputStreamK                        ,+    toDataInputStream                       ,+    noDataInputStream                       ,+++ -- * Methods+-- ** dataInputStreamGetByteOrder+    dataInputStreamGetByteOrder             ,+++-- ** dataInputStreamGetNewlineType+    dataInputStreamGetNewlineType           ,+++-- ** dataInputStreamNew+    dataInputStreamNew                      ,+++-- ** dataInputStreamReadByte+    dataInputStreamReadByte                 ,+++-- ** dataInputStreamReadInt16+    dataInputStreamReadInt16                ,+++-- ** dataInputStreamReadInt32+    dataInputStreamReadInt32                ,+++-- ** dataInputStreamReadInt64+    dataInputStreamReadInt64                ,+++-- ** dataInputStreamReadLine+    dataInputStreamReadLine                 ,+++-- ** dataInputStreamReadLineAsync+    dataInputStreamReadLineAsync            ,+++-- ** dataInputStreamReadLineFinish+    dataInputStreamReadLineFinish           ,+++-- ** dataInputStreamReadLineFinishUtf8+    dataInputStreamReadLineFinishUtf8       ,+++-- ** dataInputStreamReadLineUtf8+    dataInputStreamReadLineUtf8             ,+++-- ** dataInputStreamReadUint16+    dataInputStreamReadUint16               ,+++-- ** dataInputStreamReadUint32+    dataInputStreamReadUint32               ,+++-- ** dataInputStreamReadUint64+    dataInputStreamReadUint64               ,+++-- ** dataInputStreamReadUntil+    dataInputStreamReadUntil                ,+++-- ** dataInputStreamReadUntilAsync+    dataInputStreamReadUntilAsync           ,+++-- ** dataInputStreamReadUntilFinish+    dataInputStreamReadUntilFinish          ,+++-- ** dataInputStreamReadUpto+    dataInputStreamReadUpto                 ,+++-- ** dataInputStreamReadUptoAsync+    dataInputStreamReadUptoAsync            ,+++-- ** dataInputStreamReadUptoFinish+    dataInputStreamReadUptoFinish           ,+++-- ** dataInputStreamSetByteOrder+    dataInputStreamSetByteOrder             ,+++-- ** dataInputStreamSetNewlineType+    dataInputStreamSetNewlineType           ,+++++ -- * Properties+-- ** ByteOrder+    DataInputStreamByteOrderPropertyInfo    ,+    constructDataInputStreamByteOrder       ,+    getDataInputStreamByteOrder             ,+    setDataInputStreamByteOrder             ,+++-- ** NewlineType+    DataInputStreamNewlineTypePropertyInfo  ,+    constructDataInputStreamNewlineType     ,+    getDataInputStreamNewlineType           ,+    setDataInputStreamNewlineType           ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype DataInputStream = DataInputStream (ForeignPtr DataInputStream)+foreign import ccall "g_data_input_stream_get_type"+    c_g_data_input_stream_get_type :: IO GType++type instance ParentTypes DataInputStream = DataInputStreamParentTypes+type DataInputStreamParentTypes = '[BufferedInputStream, FilterInputStream, InputStream, GObject.Object, Seekable]++instance GObject DataInputStream where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_data_input_stream_get_type+    ++class GObject o => DataInputStreamK o+instance (GObject o, IsDescendantOf DataInputStream o) => DataInputStreamK o++toDataInputStream :: DataInputStreamK o => o -> IO DataInputStream+toDataInputStream = unsafeCastTo DataInputStream++noDataInputStream :: Maybe DataInputStream+noDataInputStream = Nothing++-- VVV Prop "byte-order"+   -- Type: TInterface "Gio" "DataStreamByteOrder"+   -- Flags: [PropertyReadable,PropertyWritable]++getDataInputStreamByteOrder :: (MonadIO m, DataInputStreamK o) => o -> m DataStreamByteOrder+getDataInputStreamByteOrder obj = liftIO $ getObjectPropertyEnum obj "byte-order"++setDataInputStreamByteOrder :: (MonadIO m, DataInputStreamK o) => o -> DataStreamByteOrder -> m ()+setDataInputStreamByteOrder obj val = liftIO $ setObjectPropertyEnum obj "byte-order" val++constructDataInputStreamByteOrder :: DataStreamByteOrder -> IO ([Char], GValue)+constructDataInputStreamByteOrder val = constructObjectPropertyEnum "byte-order" val++data DataInputStreamByteOrderPropertyInfo+instance AttrInfo DataInputStreamByteOrderPropertyInfo where+    type AttrAllowedOps DataInputStreamByteOrderPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DataInputStreamByteOrderPropertyInfo = (~) DataStreamByteOrder+    type AttrBaseTypeConstraint DataInputStreamByteOrderPropertyInfo = DataInputStreamK+    type AttrGetType DataInputStreamByteOrderPropertyInfo = DataStreamByteOrder+    type AttrLabel DataInputStreamByteOrderPropertyInfo = "DataInputStream::byte-order"+    attrGet _ = getDataInputStreamByteOrder+    attrSet _ = setDataInputStreamByteOrder+    attrConstruct _ = constructDataInputStreamByteOrder++-- VVV Prop "newline-type"+   -- Type: TInterface "Gio" "DataStreamNewlineType"+   -- Flags: [PropertyReadable,PropertyWritable]++getDataInputStreamNewlineType :: (MonadIO m, DataInputStreamK o) => o -> m DataStreamNewlineType+getDataInputStreamNewlineType obj = liftIO $ getObjectPropertyEnum obj "newline-type"++setDataInputStreamNewlineType :: (MonadIO m, DataInputStreamK o) => o -> DataStreamNewlineType -> m ()+setDataInputStreamNewlineType obj val = liftIO $ setObjectPropertyEnum obj "newline-type" val++constructDataInputStreamNewlineType :: DataStreamNewlineType -> IO ([Char], GValue)+constructDataInputStreamNewlineType val = constructObjectPropertyEnum "newline-type" val++data DataInputStreamNewlineTypePropertyInfo+instance AttrInfo DataInputStreamNewlineTypePropertyInfo where+    type AttrAllowedOps DataInputStreamNewlineTypePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DataInputStreamNewlineTypePropertyInfo = (~) DataStreamNewlineType+    type AttrBaseTypeConstraint DataInputStreamNewlineTypePropertyInfo = DataInputStreamK+    type AttrGetType DataInputStreamNewlineTypePropertyInfo = DataStreamNewlineType+    type AttrLabel DataInputStreamNewlineTypePropertyInfo = "DataInputStream::newline-type"+    attrGet _ = getDataInputStreamNewlineType+    attrSet _ = setDataInputStreamNewlineType+    attrConstruct _ = constructDataInputStreamNewlineType++type instance AttributeList DataInputStream = DataInputStreamAttributeList+type DataInputStreamAttributeList = ('[ '("base-stream", FilterInputStreamBaseStreamPropertyInfo), '("buffer-size", BufferedInputStreamBufferSizePropertyInfo), '("byte-order", DataInputStreamByteOrderPropertyInfo), '("close-base-stream", FilterInputStreamCloseBaseStreamPropertyInfo), '("newline-type", DataInputStreamNewlineTypePropertyInfo)] :: [(Symbol, *)])++type instance SignalList DataInputStream = DataInputStreamSignalList+type DataInputStreamSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method DataInputStream::new+-- method type : Constructor+-- Args : [Arg {argName = "base_stream", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "base_stream", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DataInputStream"+-- throws : False+-- Skip return : False++foreign import ccall "g_data_input_stream_new" g_data_input_stream_new :: +    Ptr InputStream ->                      -- base_stream : TInterface "Gio" "InputStream"+    IO (Ptr DataInputStream)+++dataInputStreamNew ::+    (MonadIO m, InputStreamK a) =>+    a ->                                    -- base_stream+    m DataInputStream+dataInputStreamNew base_stream = liftIO $ do+    let base_stream' = unsafeManagedPtrCastPtr base_stream+    result <- g_data_input_stream_new base_stream'+    checkUnexpectedReturnNULL "g_data_input_stream_new" result+    result' <- (wrapObject DataInputStream) result+    touchManagedPtr base_stream+    return result'++-- method DataInputStream::get_byte_order+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DataStreamByteOrder"+-- throws : False+-- Skip return : False++foreign import ccall "g_data_input_stream_get_byte_order" g_data_input_stream_get_byte_order :: +    Ptr DataInputStream ->                  -- _obj : TInterface "Gio" "DataInputStream"+    IO CUInt+++dataInputStreamGetByteOrder ::+    (MonadIO m, DataInputStreamK a) =>+    a ->                                    -- _obj+    m DataStreamByteOrder+dataInputStreamGetByteOrder _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_data_input_stream_get_byte_order _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method DataInputStream::get_newline_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DataStreamNewlineType"+-- throws : False+-- Skip return : False++foreign import ccall "g_data_input_stream_get_newline_type" g_data_input_stream_get_newline_type :: +    Ptr DataInputStream ->                  -- _obj : TInterface "Gio" "DataInputStream"+    IO CUInt+++dataInputStreamGetNewlineType ::+    (MonadIO m, DataInputStreamK a) =>+    a ->                                    -- _obj+    m DataStreamNewlineType+dataInputStreamGetNewlineType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_data_input_stream_get_newline_type _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method DataInputStream::read_byte+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt8+-- throws : True+-- Skip return : False++foreign import ccall "g_data_input_stream_read_byte" g_data_input_stream_read_byte :: +    Ptr DataInputStream ->                  -- _obj : TInterface "Gio" "DataInputStream"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO Word8+++dataInputStreamReadByte ::+    (MonadIO m, DataInputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m Word8+dataInputStreamReadByte _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_data_input_stream_read_byte _obj' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return result+     ) (do+        return ()+     )++-- method DataInputStream::read_int16+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt16+-- throws : True+-- Skip return : False++foreign import ccall "g_data_input_stream_read_int16" g_data_input_stream_read_int16 :: +    Ptr DataInputStream ->                  -- _obj : TInterface "Gio" "DataInputStream"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO Int16+++dataInputStreamReadInt16 ::+    (MonadIO m, DataInputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m Int16+dataInputStreamReadInt16 _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_data_input_stream_read_int16 _obj' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return result+     ) (do+        return ()+     )++-- method DataInputStream::read_int32+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : True+-- Skip return : False++foreign import ccall "g_data_input_stream_read_int32" g_data_input_stream_read_int32 :: +    Ptr DataInputStream ->                  -- _obj : TInterface "Gio" "DataInputStream"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO Int32+++dataInputStreamReadInt32 ::+    (MonadIO m, DataInputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m Int32+dataInputStreamReadInt32 _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_data_input_stream_read_int32 _obj' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return result+     ) (do+        return ()+     )++-- method DataInputStream::read_int64+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : True+-- Skip return : False++foreign import ccall "g_data_input_stream_read_int64" g_data_input_stream_read_int64 :: +    Ptr DataInputStream ->                  -- _obj : TInterface "Gio" "DataInputStream"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO Int64+++dataInputStreamReadInt64 ::+    (MonadIO m, DataInputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m Int64+dataInputStreamReadInt64 _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_data_input_stream_read_int64 _obj' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return result+     ) (do+        return ()+     )++-- method DataInputStream::read_line+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray True (-1) (-1) (TBasicType TUInt8)+-- throws : True+-- Skip return : False++foreign import ccall "g_data_input_stream_read_line" g_data_input_stream_read_line :: +    Ptr DataInputStream ->                  -- _obj : TInterface "Gio" "DataInputStream"+    Ptr Word64 ->                           -- length : TBasicType TUInt64+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Word8)+++dataInputStreamReadLine ::+    (MonadIO m, DataInputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m (ByteString,Word64)+dataInputStreamReadLine _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    length_ <- allocMem :: IO (Ptr Word64)+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_data_input_stream_read_line _obj' length_ maybeCancellable+        checkUnexpectedReturnNULL "g_data_input_stream_read_line" result+        result' <- unpackZeroTerminatedByteString result+        freeMem result+        length_' <- peek length_+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem length_+        return (result', length_')+     ) (do+        freeMem length_+     )++-- method DataInputStream::read_line_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_data_input_stream_read_line_async" g_data_input_stream_read_line_async :: +    Ptr DataInputStream ->                  -- _obj : TInterface "Gio" "DataInputStream"+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++dataInputStreamReadLineAsync ::+    (MonadIO m, DataInputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+dataInputStreamReadLineAsync _obj io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_data_input_stream_read_line_async _obj' io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method DataInputStream::read_line_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray True (-1) (-1) (TBasicType TUInt8)+-- throws : True+-- Skip return : False++foreign import ccall "g_data_input_stream_read_line_finish" g_data_input_stream_read_line_finish :: +    Ptr DataInputStream ->                  -- _obj : TInterface "Gio" "DataInputStream"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr Word64 ->                           -- length : TBasicType TUInt64+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Word8)+++dataInputStreamReadLineFinish ::+    (MonadIO m, DataInputStreamK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m (ByteString,Word64)+dataInputStreamReadLineFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    length_ <- allocMem :: IO (Ptr Word64)+    onException (do+        result <- propagateGError $ g_data_input_stream_read_line_finish _obj' result_' length_+        checkUnexpectedReturnNULL "g_data_input_stream_read_line_finish" result+        result' <- unpackZeroTerminatedByteString result+        freeMem result+        length_' <- peek length_+        touchManagedPtr _obj+        touchManagedPtr result_+        freeMem length_+        return (result', length_')+     ) (do+        freeMem length_+     )++-- method DataInputStream::read_line_finish_utf8+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : True+-- Skip return : False++foreign import ccall "g_data_input_stream_read_line_finish_utf8" g_data_input_stream_read_line_finish_utf8 :: +    Ptr DataInputStream ->                  -- _obj : TInterface "Gio" "DataInputStream"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr Word64 ->                           -- length : TBasicType TUInt64+    Ptr (Ptr GError) ->                     -- error+    IO CString+++dataInputStreamReadLineFinishUtf8 ::+    (MonadIO m, DataInputStreamK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m (T.Text,Word64)+dataInputStreamReadLineFinishUtf8 _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    length_ <- allocMem :: IO (Ptr Word64)+    onException (do+        result <- propagateGError $ g_data_input_stream_read_line_finish_utf8 _obj' result_' length_+        checkUnexpectedReturnNULL "g_data_input_stream_read_line_finish_utf8" result+        result' <- cstringToText result+        freeMem result+        length_' <- peek length_+        touchManagedPtr _obj+        touchManagedPtr result_+        freeMem length_+        return (result', length_')+     ) (do+        freeMem length_+     )++-- method DataInputStream::read_line_utf8+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : True+-- Skip return : False++foreign import ccall "g_data_input_stream_read_line_utf8" g_data_input_stream_read_line_utf8 :: +    Ptr DataInputStream ->                  -- _obj : TInterface "Gio" "DataInputStream"+    Ptr Word64 ->                           -- length : TBasicType TUInt64+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CString+++dataInputStreamReadLineUtf8 ::+    (MonadIO m, DataInputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m (T.Text,Word64)+dataInputStreamReadLineUtf8 _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    length_ <- allocMem :: IO (Ptr Word64)+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_data_input_stream_read_line_utf8 _obj' length_ maybeCancellable+        checkUnexpectedReturnNULL "g_data_input_stream_read_line_utf8" result+        result' <- cstringToText result+        freeMem result+        length_' <- peek length_+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem length_+        return (result', length_')+     ) (do+        freeMem length_+     )++-- method DataInputStream::read_uint16+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt16+-- throws : True+-- Skip return : False++foreign import ccall "g_data_input_stream_read_uint16" g_data_input_stream_read_uint16 :: +    Ptr DataInputStream ->                  -- _obj : TInterface "Gio" "DataInputStream"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO Word16+++dataInputStreamReadUint16 ::+    (MonadIO m, DataInputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m Word16+dataInputStreamReadUint16 _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_data_input_stream_read_uint16 _obj' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return result+     ) (do+        return ()+     )++-- method DataInputStream::read_uint32+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : True+-- Skip return : False++foreign import ccall "g_data_input_stream_read_uint32" g_data_input_stream_read_uint32 :: +    Ptr DataInputStream ->                  -- _obj : TInterface "Gio" "DataInputStream"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO Word32+++dataInputStreamReadUint32 ::+    (MonadIO m, DataInputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m Word32+dataInputStreamReadUint32 _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_data_input_stream_read_uint32 _obj' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return result+     ) (do+        return ()+     )++-- method DataInputStream::read_uint64+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt64+-- throws : True+-- Skip return : False++foreign import ccall "g_data_input_stream_read_uint64" g_data_input_stream_read_uint64 :: +    Ptr DataInputStream ->                  -- _obj : TInterface "Gio" "DataInputStream"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO Word64+++dataInputStreamReadUint64 ::+    (MonadIO m, DataInputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m Word64+dataInputStreamReadUint64 _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_data_input_stream_read_uint64 _obj' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return result+     ) (do+        return ()+     )++-- method DataInputStream::read_until+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stop_chars", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stop_chars", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : True+-- Skip return : False++foreign import ccall "g_data_input_stream_read_until" g_data_input_stream_read_until :: +    Ptr DataInputStream ->                  -- _obj : TInterface "Gio" "DataInputStream"+    CString ->                              -- stop_chars : TBasicType TUTF8+    Ptr Word64 ->                           -- length : TBasicType TUInt64+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CString+++dataInputStreamReadUntil ::+    (MonadIO m, DataInputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- stop_chars+    Maybe (b) ->                            -- cancellable+    m (T.Text,Word64)+dataInputStreamReadUntil _obj stop_chars cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    stop_chars' <- textToCString stop_chars+    length_ <- allocMem :: IO (Ptr Word64)+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_data_input_stream_read_until _obj' stop_chars' length_ maybeCancellable+        checkUnexpectedReturnNULL "g_data_input_stream_read_until" result+        result' <- cstringToText result+        freeMem result+        length_' <- peek length_+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem stop_chars'+        freeMem length_+        return (result', length_')+     ) (do+        freeMem stop_chars'+        freeMem length_+     )++-- method DataInputStream::read_until_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stop_chars", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stop_chars", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_data_input_stream_read_until_async" g_data_input_stream_read_until_async :: +    Ptr DataInputStream ->                  -- _obj : TInterface "Gio" "DataInputStream"+    CString ->                              -- stop_chars : TBasicType TUTF8+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++dataInputStreamReadUntilAsync ::+    (MonadIO m, DataInputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- stop_chars+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+dataInputStreamReadUntilAsync _obj stop_chars io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    stop_chars' <- textToCString stop_chars+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_data_input_stream_read_until_async _obj' stop_chars' io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    freeMem stop_chars'+    return ()++-- method DataInputStream::read_until_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : True+-- Skip return : False++foreign import ccall "g_data_input_stream_read_until_finish" g_data_input_stream_read_until_finish :: +    Ptr DataInputStream ->                  -- _obj : TInterface "Gio" "DataInputStream"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr Word64 ->                           -- length : TBasicType TUInt64+    Ptr (Ptr GError) ->                     -- error+    IO CString+++dataInputStreamReadUntilFinish ::+    (MonadIO m, DataInputStreamK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m (T.Text,Word64)+dataInputStreamReadUntilFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    length_ <- allocMem :: IO (Ptr Word64)+    onException (do+        result <- propagateGError $ g_data_input_stream_read_until_finish _obj' result_' length_+        checkUnexpectedReturnNULL "g_data_input_stream_read_until_finish" result+        result' <- cstringToText result+        freeMem result+        length_' <- peek length_+        touchManagedPtr _obj+        touchManagedPtr result_+        freeMem length_+        return (result', length_')+     ) (do+        freeMem length_+     )++-- method DataInputStream::read_upto+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stop_chars", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stop_chars_len", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stop_chars", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stop_chars_len", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : True+-- Skip return : False++foreign import ccall "g_data_input_stream_read_upto" g_data_input_stream_read_upto :: +    Ptr DataInputStream ->                  -- _obj : TInterface "Gio" "DataInputStream"+    CString ->                              -- stop_chars : TBasicType TUTF8+    Int64 ->                                -- stop_chars_len : TBasicType TInt64+    Ptr Word64 ->                           -- length : TBasicType TUInt64+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CString+++dataInputStreamReadUpto ::+    (MonadIO m, DataInputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- stop_chars+    Int64 ->                                -- stop_chars_len+    Maybe (b) ->                            -- cancellable+    m (T.Text,Word64)+dataInputStreamReadUpto _obj stop_chars stop_chars_len cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    stop_chars' <- textToCString stop_chars+    length_ <- allocMem :: IO (Ptr Word64)+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_data_input_stream_read_upto _obj' stop_chars' stop_chars_len length_ maybeCancellable+        checkUnexpectedReturnNULL "g_data_input_stream_read_upto" result+        result' <- cstringToText result+        freeMem result+        length_' <- peek length_+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem stop_chars'+        freeMem length_+        return (result', length_')+     ) (do+        freeMem stop_chars'+        freeMem length_+     )++-- method DataInputStream::read_upto_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stop_chars", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stop_chars_len", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stop_chars", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stop_chars_len", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_data_input_stream_read_upto_async" g_data_input_stream_read_upto_async :: +    Ptr DataInputStream ->                  -- _obj : TInterface "Gio" "DataInputStream"+    CString ->                              -- stop_chars : TBasicType TUTF8+    Int64 ->                                -- stop_chars_len : TBasicType TInt64+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++dataInputStreamReadUptoAsync ::+    (MonadIO m, DataInputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- stop_chars+    Int64 ->                                -- stop_chars_len+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+dataInputStreamReadUptoAsync _obj stop_chars stop_chars_len io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    stop_chars' <- textToCString stop_chars+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_data_input_stream_read_upto_async _obj' stop_chars' stop_chars_len io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    freeMem stop_chars'+    return ()++-- method DataInputStream::read_upto_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : True+-- Skip return : False++foreign import ccall "g_data_input_stream_read_upto_finish" g_data_input_stream_read_upto_finish :: +    Ptr DataInputStream ->                  -- _obj : TInterface "Gio" "DataInputStream"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr Word64 ->                           -- length : TBasicType TUInt64+    Ptr (Ptr GError) ->                     -- error+    IO CString+++dataInputStreamReadUptoFinish ::+    (MonadIO m, DataInputStreamK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m (T.Text,Word64)+dataInputStreamReadUptoFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    length_ <- allocMem :: IO (Ptr Word64)+    onException (do+        result <- propagateGError $ g_data_input_stream_read_upto_finish _obj' result_' length_+        checkUnexpectedReturnNULL "g_data_input_stream_read_upto_finish" result+        result' <- cstringToText result+        freeMem result+        length_' <- peek length_+        touchManagedPtr _obj+        touchManagedPtr result_+        freeMem length_+        return (result', length_')+     ) (do+        freeMem length_+     )++-- method DataInputStream::set_byte_order+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "order", argType = TInterface "Gio" "DataStreamByteOrder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "order", argType = TInterface "Gio" "DataStreamByteOrder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_data_input_stream_set_byte_order" g_data_input_stream_set_byte_order :: +    Ptr DataInputStream ->                  -- _obj : TInterface "Gio" "DataInputStream"+    CUInt ->                                -- order : TInterface "Gio" "DataStreamByteOrder"+    IO ()+++dataInputStreamSetByteOrder ::+    (MonadIO m, DataInputStreamK a) =>+    a ->                                    -- _obj+    DataStreamByteOrder ->                  -- order+    m ()+dataInputStreamSetByteOrder _obj order = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let order' = (fromIntegral . fromEnum) order+    g_data_input_stream_set_byte_order _obj' order'+    touchManagedPtr _obj+    return ()++-- method DataInputStream::set_newline_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "Gio" "DataStreamNewlineType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DataInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "Gio" "DataStreamNewlineType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_data_input_stream_set_newline_type" g_data_input_stream_set_newline_type :: +    Ptr DataInputStream ->                  -- _obj : TInterface "Gio" "DataInputStream"+    CUInt ->                                -- type : TInterface "Gio" "DataStreamNewlineType"+    IO ()+++dataInputStreamSetNewlineType ::+    (MonadIO m, DataInputStreamK a) =>+    a ->                                    -- _obj+    DataStreamNewlineType ->                -- type+    m ()+dataInputStreamSetNewlineType _obj type_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let type_' = (fromIntegral . fromEnum) type_+    g_data_input_stream_set_newline_type _obj' type_'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Objects/DataInputStream.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gio.Objects.DataInputStream where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype DataInputStream = DataInputStream (ForeignPtr DataInputStream)+instance GObject DataInputStream where+class GObject o => DataInputStreamK o+instance (GObject o, IsDescendantOf DataInputStream o) => DataInputStreamK o+data DataInputStreamByteOrderPropertyInfo+data DataInputStreamNewlineTypePropertyInfo
+ GI/Gio/Objects/DataOutputStream.hs view
@@ -0,0 +1,531 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.DataOutputStream+    ( ++-- * Exported types+    DataOutputStream(..)                    ,+    DataOutputStreamK                       ,+    toDataOutputStream                      ,+    noDataOutputStream                      ,+++ -- * Methods+-- ** dataOutputStreamGetByteOrder+    dataOutputStreamGetByteOrder            ,+++-- ** dataOutputStreamNew+    dataOutputStreamNew                     ,+++-- ** dataOutputStreamPutByte+    dataOutputStreamPutByte                 ,+++-- ** dataOutputStreamPutInt16+    dataOutputStreamPutInt16                ,+++-- ** dataOutputStreamPutInt32+    dataOutputStreamPutInt32                ,+++-- ** dataOutputStreamPutInt64+    dataOutputStreamPutInt64                ,+++-- ** dataOutputStreamPutString+    dataOutputStreamPutString               ,+++-- ** dataOutputStreamPutUint16+    dataOutputStreamPutUint16               ,+++-- ** dataOutputStreamPutUint32+    dataOutputStreamPutUint32               ,+++-- ** dataOutputStreamPutUint64+    dataOutputStreamPutUint64               ,+++-- ** dataOutputStreamSetByteOrder+    dataOutputStreamSetByteOrder            ,+++++ -- * Properties+-- ** ByteOrder+    DataOutputStreamByteOrderPropertyInfo   ,+    constructDataOutputStreamByteOrder      ,+    getDataOutputStreamByteOrder            ,+    setDataOutputStreamByteOrder            ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype DataOutputStream = DataOutputStream (ForeignPtr DataOutputStream)+foreign import ccall "g_data_output_stream_get_type"+    c_g_data_output_stream_get_type :: IO GType++type instance ParentTypes DataOutputStream = DataOutputStreamParentTypes+type DataOutputStreamParentTypes = '[FilterOutputStream, OutputStream, GObject.Object, Seekable]++instance GObject DataOutputStream where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_data_output_stream_get_type+    ++class GObject o => DataOutputStreamK o+instance (GObject o, IsDescendantOf DataOutputStream o) => DataOutputStreamK o++toDataOutputStream :: DataOutputStreamK o => o -> IO DataOutputStream+toDataOutputStream = unsafeCastTo DataOutputStream++noDataOutputStream :: Maybe DataOutputStream+noDataOutputStream = Nothing++-- VVV Prop "byte-order"+   -- Type: TInterface "Gio" "DataStreamByteOrder"+   -- Flags: [PropertyReadable,PropertyWritable]++getDataOutputStreamByteOrder :: (MonadIO m, DataOutputStreamK o) => o -> m DataStreamByteOrder+getDataOutputStreamByteOrder obj = liftIO $ getObjectPropertyEnum obj "byte-order"++setDataOutputStreamByteOrder :: (MonadIO m, DataOutputStreamK o) => o -> DataStreamByteOrder -> m ()+setDataOutputStreamByteOrder obj val = liftIO $ setObjectPropertyEnum obj "byte-order" val++constructDataOutputStreamByteOrder :: DataStreamByteOrder -> IO ([Char], GValue)+constructDataOutputStreamByteOrder val = constructObjectPropertyEnum "byte-order" val++data DataOutputStreamByteOrderPropertyInfo+instance AttrInfo DataOutputStreamByteOrderPropertyInfo where+    type AttrAllowedOps DataOutputStreamByteOrderPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DataOutputStreamByteOrderPropertyInfo = (~) DataStreamByteOrder+    type AttrBaseTypeConstraint DataOutputStreamByteOrderPropertyInfo = DataOutputStreamK+    type AttrGetType DataOutputStreamByteOrderPropertyInfo = DataStreamByteOrder+    type AttrLabel DataOutputStreamByteOrderPropertyInfo = "DataOutputStream::byte-order"+    attrGet _ = getDataOutputStreamByteOrder+    attrSet _ = setDataOutputStreamByteOrder+    attrConstruct _ = constructDataOutputStreamByteOrder++type instance AttributeList DataOutputStream = DataOutputStreamAttributeList+type DataOutputStreamAttributeList = ('[ '("base-stream", FilterOutputStreamBaseStreamPropertyInfo), '("byte-order", DataOutputStreamByteOrderPropertyInfo), '("close-base-stream", FilterOutputStreamCloseBaseStreamPropertyInfo)] :: [(Symbol, *)])++type instance SignalList DataOutputStream = DataOutputStreamSignalList+type DataOutputStreamSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method DataOutputStream::new+-- method type : Constructor+-- Args : [Arg {argName = "base_stream", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "base_stream", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DataOutputStream"+-- throws : False+-- Skip return : False++foreign import ccall "g_data_output_stream_new" g_data_output_stream_new :: +    Ptr OutputStream ->                     -- base_stream : TInterface "Gio" "OutputStream"+    IO (Ptr DataOutputStream)+++dataOutputStreamNew ::+    (MonadIO m, OutputStreamK a) =>+    a ->                                    -- base_stream+    m DataOutputStream+dataOutputStreamNew base_stream = liftIO $ do+    let base_stream' = unsafeManagedPtrCastPtr base_stream+    result <- g_data_output_stream_new base_stream'+    checkUnexpectedReturnNULL "g_data_output_stream_new" result+    result' <- (wrapObject DataOutputStream) result+    touchManagedPtr base_stream+    return result'++-- method DataOutputStream::get_byte_order+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DataOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DataOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DataStreamByteOrder"+-- throws : False+-- Skip return : False++foreign import ccall "g_data_output_stream_get_byte_order" g_data_output_stream_get_byte_order :: +    Ptr DataOutputStream ->                 -- _obj : TInterface "Gio" "DataOutputStream"+    IO CUInt+++dataOutputStreamGetByteOrder ::+    (MonadIO m, DataOutputStreamK a) =>+    a ->                                    -- _obj+    m DataStreamByteOrder+dataOutputStreamGetByteOrder _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_data_output_stream_get_byte_order _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method DataOutputStream::put_byte+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DataOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "data", argType = TBasicType TUInt8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DataOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "data", argType = TBasicType TUInt8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_data_output_stream_put_byte" g_data_output_stream_put_byte :: +    Ptr DataOutputStream ->                 -- _obj : TInterface "Gio" "DataOutputStream"+    Word8 ->                                -- data : TBasicType TUInt8+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++dataOutputStreamPutByte ::+    (MonadIO m, DataOutputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Word8 ->                                -- data+    Maybe (b) ->                            -- cancellable+    m ()+dataOutputStreamPutByte _obj data_ cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_data_output_stream_put_byte _obj' data_ maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method DataOutputStream::put_int16+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DataOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "data", argType = TBasicType TInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DataOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "data", argType = TBasicType TInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_data_output_stream_put_int16" g_data_output_stream_put_int16 :: +    Ptr DataOutputStream ->                 -- _obj : TInterface "Gio" "DataOutputStream"+    Int16 ->                                -- data : TBasicType TInt16+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++dataOutputStreamPutInt16 ::+    (MonadIO m, DataOutputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Int16 ->                                -- data+    Maybe (b) ->                            -- cancellable+    m ()+dataOutputStreamPutInt16 _obj data_ cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_data_output_stream_put_int16 _obj' data_ maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method DataOutputStream::put_int32+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DataOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "data", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DataOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "data", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_data_output_stream_put_int32" g_data_output_stream_put_int32 :: +    Ptr DataOutputStream ->                 -- _obj : TInterface "Gio" "DataOutputStream"+    Int32 ->                                -- data : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++dataOutputStreamPutInt32 ::+    (MonadIO m, DataOutputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Int32 ->                                -- data+    Maybe (b) ->                            -- cancellable+    m ()+dataOutputStreamPutInt32 _obj data_ cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_data_output_stream_put_int32 _obj' data_ maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method DataOutputStream::put_int64+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DataOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "data", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DataOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "data", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_data_output_stream_put_int64" g_data_output_stream_put_int64 :: +    Ptr DataOutputStream ->                 -- _obj : TInterface "Gio" "DataOutputStream"+    Int64 ->                                -- data : TBasicType TInt64+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++dataOutputStreamPutInt64 ::+    (MonadIO m, DataOutputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Int64 ->                                -- data+    Maybe (b) ->                            -- cancellable+    m ()+dataOutputStreamPutInt64 _obj data_ cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_data_output_stream_put_int64 _obj' data_ maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method DataOutputStream::put_string+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DataOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "str", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DataOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "str", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_data_output_stream_put_string" g_data_output_stream_put_string :: +    Ptr DataOutputStream ->                 -- _obj : TInterface "Gio" "DataOutputStream"+    CString ->                              -- str : TBasicType TUTF8+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++dataOutputStreamPutString ::+    (MonadIO m, DataOutputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- str+    Maybe (b) ->                            -- cancellable+    m ()+dataOutputStreamPutString _obj str cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    str' <- textToCString str+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_data_output_stream_put_string _obj' str' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem str'+        return ()+     ) (do+        freeMem str'+     )++-- method DataOutputStream::put_uint16+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DataOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "data", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DataOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "data", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_data_output_stream_put_uint16" g_data_output_stream_put_uint16 :: +    Ptr DataOutputStream ->                 -- _obj : TInterface "Gio" "DataOutputStream"+    Word16 ->                               -- data : TBasicType TUInt16+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++dataOutputStreamPutUint16 ::+    (MonadIO m, DataOutputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Word16 ->                               -- data+    Maybe (b) ->                            -- cancellable+    m ()+dataOutputStreamPutUint16 _obj data_ cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_data_output_stream_put_uint16 _obj' data_ maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method DataOutputStream::put_uint32+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DataOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "data", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DataOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "data", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_data_output_stream_put_uint32" g_data_output_stream_put_uint32 :: +    Ptr DataOutputStream ->                 -- _obj : TInterface "Gio" "DataOutputStream"+    Word32 ->                               -- data : TBasicType TUInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++dataOutputStreamPutUint32 ::+    (MonadIO m, DataOutputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Word32 ->                               -- data+    Maybe (b) ->                            -- cancellable+    m ()+dataOutputStreamPutUint32 _obj data_ cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_data_output_stream_put_uint32 _obj' data_ maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method DataOutputStream::put_uint64+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DataOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "data", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DataOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "data", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_data_output_stream_put_uint64" g_data_output_stream_put_uint64 :: +    Ptr DataOutputStream ->                 -- _obj : TInterface "Gio" "DataOutputStream"+    Word64 ->                               -- data : TBasicType TUInt64+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++dataOutputStreamPutUint64 ::+    (MonadIO m, DataOutputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Word64 ->                               -- data+    Maybe (b) ->                            -- cancellable+    m ()+dataOutputStreamPutUint64 _obj data_ cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_data_output_stream_put_uint64 _obj' data_ maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method DataOutputStream::set_byte_order+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DataOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "order", argType = TInterface "Gio" "DataStreamByteOrder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DataOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "order", argType = TInterface "Gio" "DataStreamByteOrder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_data_output_stream_set_byte_order" g_data_output_stream_set_byte_order :: +    Ptr DataOutputStream ->                 -- _obj : TInterface "Gio" "DataOutputStream"+    CUInt ->                                -- order : TInterface "Gio" "DataStreamByteOrder"+    IO ()+++dataOutputStreamSetByteOrder ::+    (MonadIO m, DataOutputStreamK a) =>+    a ->                                    -- _obj+    DataStreamByteOrder ->                  -- order+    m ()+dataOutputStreamSetByteOrder _obj order = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let order' = (fromIntegral . fromEnum) order+    g_data_output_stream_set_byte_order _obj' order'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Objects/DataOutputStream.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gio.Objects.DataOutputStream where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype DataOutputStream = DataOutputStream (ForeignPtr DataOutputStream)+instance GObject DataOutputStream where+class GObject o => DataOutputStreamK o+instance (GObject o, IsDescendantOf DataOutputStream o) => DataOutputStreamK o+data DataOutputStreamByteOrderPropertyInfo
+ GI/Gio/Objects/DesktopAppInfo.hs view
@@ -0,0 +1,729 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.DesktopAppInfo+    ( ++-- * Exported types+    DesktopAppInfo(..)                      ,+    DesktopAppInfoK                         ,+    toDesktopAppInfo                        ,+    noDesktopAppInfo                        ,+++ -- * Methods+-- ** desktopAppInfoGetActionName+    desktopAppInfoGetActionName             ,+++-- ** desktopAppInfoGetBoolean+    desktopAppInfoGetBoolean                ,+++-- ** desktopAppInfoGetCategories+    desktopAppInfoGetCategories             ,+++-- ** desktopAppInfoGetFilename+    desktopAppInfoGetFilename               ,+++-- ** desktopAppInfoGetGenericName+    desktopAppInfoGetGenericName            ,+++-- ** desktopAppInfoGetImplementations+    desktopAppInfoGetImplementations        ,+++-- ** desktopAppInfoGetIsHidden+    desktopAppInfoGetIsHidden               ,+++-- ** desktopAppInfoGetKeywords+    desktopAppInfoGetKeywords               ,+++-- ** desktopAppInfoGetNodisplay+    desktopAppInfoGetNodisplay              ,+++-- ** desktopAppInfoGetShowIn+    desktopAppInfoGetShowIn                 ,+++-- ** desktopAppInfoGetStartupWmClass+    desktopAppInfoGetStartupWmClass         ,+++-- ** desktopAppInfoGetString+    desktopAppInfoGetString                 ,+++-- ** desktopAppInfoHasKey+    desktopAppInfoHasKey                    ,+++-- ** desktopAppInfoLaunchAction+    desktopAppInfoLaunchAction              ,+++-- ** desktopAppInfoListActions+    desktopAppInfoListActions               ,+++-- ** desktopAppInfoNew+    desktopAppInfoNew                       ,+++-- ** desktopAppInfoNewFromFilename+    desktopAppInfoNewFromFilename           ,+++-- ** desktopAppInfoNewFromKeyfile+    desktopAppInfoNewFromKeyfile            ,+++-- ** desktopAppInfoSearch+    desktopAppInfoSearch                    ,+++-- ** desktopAppInfoSetDesktopEnv+    desktopAppInfoSetDesktopEnv             ,+++++ -- * Properties+-- ** Filename+    DesktopAppInfoFilenamePropertyInfo      ,+    constructDesktopAppInfoFilename         ,+    getDesktopAppInfoFilename               ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype DesktopAppInfo = DesktopAppInfo (ForeignPtr DesktopAppInfo)+foreign import ccall "g_desktop_app_info_get_type"+    c_g_desktop_app_info_get_type :: IO GType++type instance ParentTypes DesktopAppInfo = DesktopAppInfoParentTypes+type DesktopAppInfoParentTypes = '[GObject.Object, AppInfo]++instance GObject DesktopAppInfo where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_desktop_app_info_get_type+    ++class GObject o => DesktopAppInfoK o+instance (GObject o, IsDescendantOf DesktopAppInfo o) => DesktopAppInfoK o++toDesktopAppInfo :: DesktopAppInfoK o => o -> IO DesktopAppInfo+toDesktopAppInfo = unsafeCastTo DesktopAppInfo++noDesktopAppInfo :: Maybe DesktopAppInfo+noDesktopAppInfo = Nothing++-- VVV Prop "filename"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getDesktopAppInfoFilename :: (MonadIO m, DesktopAppInfoK o) => o -> m T.Text+getDesktopAppInfoFilename obj = liftIO $ getObjectPropertyString obj "filename"++constructDesktopAppInfoFilename :: T.Text -> IO ([Char], GValue)+constructDesktopAppInfoFilename val = constructObjectPropertyString "filename" val++data DesktopAppInfoFilenamePropertyInfo+instance AttrInfo DesktopAppInfoFilenamePropertyInfo where+    type AttrAllowedOps DesktopAppInfoFilenamePropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DesktopAppInfoFilenamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint DesktopAppInfoFilenamePropertyInfo = DesktopAppInfoK+    type AttrGetType DesktopAppInfoFilenamePropertyInfo = T.Text+    type AttrLabel DesktopAppInfoFilenamePropertyInfo = "DesktopAppInfo::filename"+    attrGet _ = getDesktopAppInfoFilename+    attrSet _ = undefined+    attrConstruct _ = constructDesktopAppInfoFilename++type instance AttributeList DesktopAppInfo = DesktopAppInfoAttributeList+type DesktopAppInfoAttributeList = ('[ '("filename", DesktopAppInfoFilenamePropertyInfo)] :: [(Symbol, *)])++type instance SignalList DesktopAppInfo = DesktopAppInfoSignalList+type DesktopAppInfoSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method DesktopAppInfo::new+-- method type : Constructor+-- Args : [Arg {argName = "desktop_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "desktop_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DesktopAppInfo"+-- throws : False+-- Skip return : False++foreign import ccall "g_desktop_app_info_new" g_desktop_app_info_new :: +    CString ->                              -- desktop_id : TBasicType TUTF8+    IO (Ptr DesktopAppInfo)+++desktopAppInfoNew ::+    (MonadIO m) =>+    T.Text ->                               -- desktop_id+    m DesktopAppInfo+desktopAppInfoNew desktop_id = liftIO $ do+    desktop_id' <- textToCString desktop_id+    result <- g_desktop_app_info_new desktop_id'+    checkUnexpectedReturnNULL "g_desktop_app_info_new" result+    result' <- (wrapObject DesktopAppInfo) result+    freeMem desktop_id'+    return result'++-- method DesktopAppInfo::new_from_filename+-- method type : Constructor+-- Args : [Arg {argName = "filename", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "filename", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DesktopAppInfo"+-- throws : False+-- Skip return : False++foreign import ccall "g_desktop_app_info_new_from_filename" g_desktop_app_info_new_from_filename :: +    CString ->                              -- filename : TBasicType TUTF8+    IO (Ptr DesktopAppInfo)+++desktopAppInfoNewFromFilename ::+    (MonadIO m) =>+    T.Text ->                               -- filename+    m DesktopAppInfo+desktopAppInfoNewFromFilename filename = liftIO $ do+    filename' <- textToCString filename+    result <- g_desktop_app_info_new_from_filename filename'+    checkUnexpectedReturnNULL "g_desktop_app_info_new_from_filename" result+    result' <- (wrapObject DesktopAppInfo) result+    freeMem filename'+    return result'++-- method DesktopAppInfo::new_from_keyfile+-- method type : Constructor+-- Args : [Arg {argName = "key_file", argType = TInterface "GLib" "KeyFile", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "key_file", argType = TInterface "GLib" "KeyFile", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DesktopAppInfo"+-- throws : False+-- Skip return : False++foreign import ccall "g_desktop_app_info_new_from_keyfile" g_desktop_app_info_new_from_keyfile :: +    Ptr GLib.KeyFile ->                     -- key_file : TInterface "GLib" "KeyFile"+    IO (Ptr DesktopAppInfo)+++desktopAppInfoNewFromKeyfile ::+    (MonadIO m) =>+    GLib.KeyFile ->                         -- key_file+    m DesktopAppInfo+desktopAppInfoNewFromKeyfile key_file = liftIO $ do+    let key_file' = unsafeManagedPtrGetPtr key_file+    result <- g_desktop_app_info_new_from_keyfile key_file'+    checkUnexpectedReturnNULL "g_desktop_app_info_new_from_keyfile" result+    result' <- (wrapObject DesktopAppInfo) result+    touchManagedPtr key_file+    return result'++-- method DesktopAppInfo::get_action_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DesktopAppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DesktopAppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_desktop_app_info_get_action_name" g_desktop_app_info_get_action_name :: +    Ptr DesktopAppInfo ->                   -- _obj : TInterface "Gio" "DesktopAppInfo"+    CString ->                              -- action_name : TBasicType TUTF8+    IO CString+++desktopAppInfoGetActionName ::+    (MonadIO m, DesktopAppInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- action_name+    m T.Text+desktopAppInfoGetActionName _obj action_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    action_name' <- textToCString action_name+    result <- g_desktop_app_info_get_action_name _obj' action_name'+    checkUnexpectedReturnNULL "g_desktop_app_info_get_action_name" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    freeMem action_name'+    return result'++-- method DesktopAppInfo::get_boolean+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DesktopAppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DesktopAppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_desktop_app_info_get_boolean" g_desktop_app_info_get_boolean :: +    Ptr DesktopAppInfo ->                   -- _obj : TInterface "Gio" "DesktopAppInfo"+    CString ->                              -- key : TBasicType TUTF8+    IO CInt+++desktopAppInfoGetBoolean ::+    (MonadIO m, DesktopAppInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    m Bool+desktopAppInfoGetBoolean _obj key = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    result <- g_desktop_app_info_get_boolean _obj' key'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem key'+    return result'++-- method DesktopAppInfo::get_categories+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DesktopAppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DesktopAppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_desktop_app_info_get_categories" g_desktop_app_info_get_categories :: +    Ptr DesktopAppInfo ->                   -- _obj : TInterface "Gio" "DesktopAppInfo"+    IO CString+++desktopAppInfoGetCategories ::+    (MonadIO m, DesktopAppInfoK a) =>+    a ->                                    -- _obj+    m T.Text+desktopAppInfoGetCategories _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_desktop_app_info_get_categories _obj'+    checkUnexpectedReturnNULL "g_desktop_app_info_get_categories" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method DesktopAppInfo::get_filename+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DesktopAppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DesktopAppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_desktop_app_info_get_filename" g_desktop_app_info_get_filename :: +    Ptr DesktopAppInfo ->                   -- _obj : TInterface "Gio" "DesktopAppInfo"+    IO CString+++desktopAppInfoGetFilename ::+    (MonadIO m, DesktopAppInfoK a) =>+    a ->                                    -- _obj+    m T.Text+desktopAppInfoGetFilename _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_desktop_app_info_get_filename _obj'+    checkUnexpectedReturnNULL "g_desktop_app_info_get_filename" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method DesktopAppInfo::get_generic_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DesktopAppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DesktopAppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_desktop_app_info_get_generic_name" g_desktop_app_info_get_generic_name :: +    Ptr DesktopAppInfo ->                   -- _obj : TInterface "Gio" "DesktopAppInfo"+    IO CString+++desktopAppInfoGetGenericName ::+    (MonadIO m, DesktopAppInfoK a) =>+    a ->                                    -- _obj+    m T.Text+desktopAppInfoGetGenericName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_desktop_app_info_get_generic_name _obj'+    checkUnexpectedReturnNULL "g_desktop_app_info_get_generic_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method DesktopAppInfo::get_is_hidden+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DesktopAppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DesktopAppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_desktop_app_info_get_is_hidden" g_desktop_app_info_get_is_hidden :: +    Ptr DesktopAppInfo ->                   -- _obj : TInterface "Gio" "DesktopAppInfo"+    IO CInt+++desktopAppInfoGetIsHidden ::+    (MonadIO m, DesktopAppInfoK a) =>+    a ->                                    -- _obj+    m Bool+desktopAppInfoGetIsHidden _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_desktop_app_info_get_is_hidden _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method DesktopAppInfo::get_keywords+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DesktopAppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DesktopAppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_desktop_app_info_get_keywords" g_desktop_app_info_get_keywords :: +    Ptr DesktopAppInfo ->                   -- _obj : TInterface "Gio" "DesktopAppInfo"+    IO (Ptr CString)+++desktopAppInfoGetKeywords ::+    (MonadIO m, DesktopAppInfoK a) =>+    a ->                                    -- _obj+    m [T.Text]+desktopAppInfoGetKeywords _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_desktop_app_info_get_keywords _obj'+    checkUnexpectedReturnNULL "g_desktop_app_info_get_keywords" result+    result' <- unpackZeroTerminatedUTF8CArray result+    touchManagedPtr _obj+    return result'++-- method DesktopAppInfo::get_nodisplay+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DesktopAppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DesktopAppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_desktop_app_info_get_nodisplay" g_desktop_app_info_get_nodisplay :: +    Ptr DesktopAppInfo ->                   -- _obj : TInterface "Gio" "DesktopAppInfo"+    IO CInt+++desktopAppInfoGetNodisplay ::+    (MonadIO m, DesktopAppInfoK a) =>+    a ->                                    -- _obj+    m Bool+desktopAppInfoGetNodisplay _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_desktop_app_info_get_nodisplay _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method DesktopAppInfo::get_show_in+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DesktopAppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "desktop_env", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DesktopAppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "desktop_env", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_desktop_app_info_get_show_in" g_desktop_app_info_get_show_in :: +    Ptr DesktopAppInfo ->                   -- _obj : TInterface "Gio" "DesktopAppInfo"+    CString ->                              -- desktop_env : TBasicType TUTF8+    IO CInt+++desktopAppInfoGetShowIn ::+    (MonadIO m, DesktopAppInfoK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- desktop_env+    m Bool+desktopAppInfoGetShowIn _obj desktop_env = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeDesktop_env <- case desktop_env of+        Nothing -> return nullPtr+        Just jDesktop_env -> do+            jDesktop_env' <- textToCString jDesktop_env+            return jDesktop_env'+    result <- g_desktop_app_info_get_show_in _obj' maybeDesktop_env+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem maybeDesktop_env+    return result'++-- method DesktopAppInfo::get_startup_wm_class+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DesktopAppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DesktopAppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_desktop_app_info_get_startup_wm_class" g_desktop_app_info_get_startup_wm_class :: +    Ptr DesktopAppInfo ->                   -- _obj : TInterface "Gio" "DesktopAppInfo"+    IO CString+++desktopAppInfoGetStartupWmClass ::+    (MonadIO m, DesktopAppInfoK a) =>+    a ->                                    -- _obj+    m T.Text+desktopAppInfoGetStartupWmClass _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_desktop_app_info_get_startup_wm_class _obj'+    checkUnexpectedReturnNULL "g_desktop_app_info_get_startup_wm_class" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method DesktopAppInfo::get_string+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DesktopAppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DesktopAppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_desktop_app_info_get_string" g_desktop_app_info_get_string :: +    Ptr DesktopAppInfo ->                   -- _obj : TInterface "Gio" "DesktopAppInfo"+    CString ->                              -- key : TBasicType TUTF8+    IO CString+++desktopAppInfoGetString ::+    (MonadIO m, DesktopAppInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    m T.Text+desktopAppInfoGetString _obj key = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    result <- g_desktop_app_info_get_string _obj' key'+    checkUnexpectedReturnNULL "g_desktop_app_info_get_string" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    freeMem key'+    return result'++-- method DesktopAppInfo::has_key+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DesktopAppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DesktopAppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_desktop_app_info_has_key" g_desktop_app_info_has_key :: +    Ptr DesktopAppInfo ->                   -- _obj : TInterface "Gio" "DesktopAppInfo"+    CString ->                              -- key : TBasicType TUTF8+    IO CInt+++desktopAppInfoHasKey ::+    (MonadIO m, DesktopAppInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    m Bool+desktopAppInfoHasKey _obj key = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    result <- g_desktop_app_info_has_key _obj' key'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem key'+    return result'++-- method DesktopAppInfo::launch_action+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DesktopAppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "launch_context", argType = TInterface "Gio" "AppLaunchContext", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DesktopAppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "launch_context", argType = TInterface "Gio" "AppLaunchContext", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_desktop_app_info_launch_action" g_desktop_app_info_launch_action :: +    Ptr DesktopAppInfo ->                   -- _obj : TInterface "Gio" "DesktopAppInfo"+    CString ->                              -- action_name : TBasicType TUTF8+    Ptr AppLaunchContext ->                 -- launch_context : TInterface "Gio" "AppLaunchContext"+    IO ()+++desktopAppInfoLaunchAction ::+    (MonadIO m, DesktopAppInfoK a, AppLaunchContextK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- action_name+    Maybe (b) ->                            -- launch_context+    m ()+desktopAppInfoLaunchAction _obj action_name launch_context = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    action_name' <- textToCString action_name+    maybeLaunch_context <- case launch_context of+        Nothing -> return nullPtr+        Just jLaunch_context -> do+            let jLaunch_context' = unsafeManagedPtrCastPtr jLaunch_context+            return jLaunch_context'+    g_desktop_app_info_launch_action _obj' action_name' maybeLaunch_context+    touchManagedPtr _obj+    whenJust launch_context touchManagedPtr+    freeMem action_name'+    return ()++-- XXX Could not generate method DesktopAppInfo::launch_uris_as_manager+-- Error was : Bad introspection data: "Closure not found! Callable\n  { returnType = TBasicType TBoolean\n  , returnMayBeNull = False\n  , returnTransfer = TransferNothing\n  , args =\n      [ Arg\n          { argName = \"_obj\"\n          , argType = TInterface \"Gio\" \"DesktopAppInfo\"\n          , direction = DirectionIn\n          , mayBeNull = False\n          , argScope = ScopeTypeInvalid\n          , argClosure = -1\n          , argDestroy = -1\n          , transfer = TransferNothing\n          }\n      , Arg\n          { argName = \"uris\"\n          , argType = TGList (TBasicType TUTF8)\n          , direction = DirectionIn\n          , mayBeNull = False\n          , argScope = ScopeTypeInvalid\n          , argClosure = -1\n          , argDestroy = -1\n          , transfer = TransferNothing\n          }\n      , Arg\n          { argName = \"launch_context\"\n          , argType = TInterface \"Gio\" \"AppLaunchContext\"\n          , direction = DirectionIn\n          , mayBeNull = True\n          , argScope = ScopeTypeInvalid\n          , argClosure = -1\n          , argDestroy = -1\n          , transfer = TransferNothing\n          }\n      , Arg\n          { argName = \"spawn_flags\"\n          , argType = TInterface \"GLib\" \"SpawnFlags\"\n          , direction = DirectionIn\n          , mayBeNull = False\n          , argScope = ScopeTypeInvalid\n          , argClosure = -1\n          , argDestroy = -1\n          , transfer = TransferNothing\n          }\n      , Arg\n          { argName = \"user_setup\"\n          , argType = TInterface \"GLib\" \"SpawnChildSetupFunc\"\n          , direction = DirectionIn\n          , mayBeNull = True\n          , argScope = ScopeTypeCall\n          , argClosure = 5\n          , argDestroy = -1\n          , transfer = TransferNothing\n          }\n      , Arg\n          { argName = \"user_setup_data\"\n          , argType = TBasicType TVoid\n          , direction = DirectionIn\n          , mayBeNull = True\n          , argScope = ScopeTypeInvalid\n          , argClosure = 4\n          , argDestroy = -1\n          , transfer = TransferNothing\n          }\n      , Arg\n          { argName = \"pid_callback\"\n          , argType = TInterface \"Gio\" \"DesktopAppLaunchCallback\"\n          , direction = DirectionIn\n          , mayBeNull = True\n          , argScope = ScopeTypeCall\n          , argClosure = 7\n          , argDestroy = -1\n          , transfer = TransferNothing\n          }\n      , Arg\n          { argName = \"pid_callback_data\"\n          , argType = TBasicType TVoid\n          , direction = DirectionIn\n          , mayBeNull = True\n          , argScope = ScopeTypeInvalid\n          , argClosure = 6\n          , argDestroy = -1\n          , transfer = TransferNothing\n          }\n      ]\n  , skipReturn = False\n  , callableDeprecated = Nothing\n  }\nfromList\n  [ ( 5\n    , Arg\n        { argName = \"user_setup\"\n        , argType = TInterface \"GLib\" \"SpawnChildSetupFunc\"\n        , direction = DirectionIn\n        , mayBeNull = True\n        , argScope = ScopeTypeCall\n        , argClosure = 5\n        , argDestroy = -1\n        , transfer = TransferNothing\n        }\n    )\n  , ( 7\n    , Arg\n        { argName = \"pid_callback\"\n        , argType = TInterface \"Gio\" \"DesktopAppLaunchCallback\"\n        , direction = DirectionIn\n        , mayBeNull = True\n        , argScope = ScopeTypeCall\n        , argClosure = 7\n        , argDestroy = -1\n        , transfer = TransferNothing\n        }\n    )\n  ]\n4"+-- method DesktopAppInfo::list_actions+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DesktopAppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DesktopAppInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_desktop_app_info_list_actions" g_desktop_app_info_list_actions :: +    Ptr DesktopAppInfo ->                   -- _obj : TInterface "Gio" "DesktopAppInfo"+    IO (Ptr CString)+++desktopAppInfoListActions ::+    (MonadIO m, DesktopAppInfoK a) =>+    a ->                                    -- _obj+    m [T.Text]+desktopAppInfoListActions _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_desktop_app_info_list_actions _obj'+    checkUnexpectedReturnNULL "g_desktop_app_info_list_actions" result+    result' <- unpackZeroTerminatedUTF8CArray result+    touchManagedPtr _obj+    return result'++-- method DesktopAppInfo::get_implementations+-- method type : MemberFunction+-- Args : [Arg {argName = "interface", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "interface", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gio" "DesktopAppInfo")+-- throws : False+-- Skip return : False++foreign import ccall "g_desktop_app_info_get_implementations" g_desktop_app_info_get_implementations :: +    CString ->                              -- interface : TBasicType TUTF8+    IO (Ptr (GList (Ptr DesktopAppInfo)))+++desktopAppInfoGetImplementations ::+    (MonadIO m) =>+    T.Text ->                               -- interface+    m [DesktopAppInfo]+desktopAppInfoGetImplementations interface = liftIO $ do+    interface' <- textToCString interface+    result <- g_desktop_app_info_get_implementations interface'+    checkUnexpectedReturnNULL "g_desktop_app_info_get_implementations" result+    result' <- unpackGList result+    result'' <- mapM (wrapObject DesktopAppInfo) result'+    g_list_free result+    freeMem interface'+    return result''++-- method DesktopAppInfo::search+-- method type : MemberFunction+-- Args : [Arg {argName = "search_string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "search_string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray True (-1) (-1) (TCArray True (-1) (-1) (TBasicType TUTF8))+-- throws : False+-- Skip return : False++foreign import ccall "g_desktop_app_info_search" g_desktop_app_info_search :: +    CString ->                              -- search_string : TBasicType TUTF8+    IO (Ptr (Ptr CString))+++desktopAppInfoSearch ::+    (MonadIO m) =>+    T.Text ->                               -- search_string+    m [[T.Text]]+desktopAppInfoSearch search_string = liftIO $ do+    search_string' <- textToCString search_string+    result <- g_desktop_app_info_search search_string'+    checkUnexpectedReturnNULL "g_desktop_app_info_search" result+    result' <- unpackZeroTerminatedPtrArray result+    result'' <- mapM unpackZeroTerminatedUTF8CArray result'+    let freeElemOfResult e = mapZeroTerminatedCArray freeMem e >> freeMem e+    mapZeroTerminatedCArray freeElemOfResult result+    freeMem result+    freeMem search_string'+    return result''++-- method DesktopAppInfo::set_desktop_env+-- method type : MemberFunction+-- Args : [Arg {argName = "desktop_env", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "desktop_env", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_desktop_app_info_set_desktop_env" g_desktop_app_info_set_desktop_env :: +    CString ->                              -- desktop_env : TBasicType TUTF8+    IO ()++{-# DEPRECATED desktopAppInfoSetDesktopEnv ["(Since version 2.42)","do not use this API.  Since 2.42 the value of the","`XDG_CURRENT_DESKTOP` environment variable will be used."]#-}+desktopAppInfoSetDesktopEnv ::+    (MonadIO m) =>+    T.Text ->                               -- desktop_env+    m ()+desktopAppInfoSetDesktopEnv desktop_env = liftIO $ do+    desktop_env' <- textToCString desktop_env+    g_desktop_app_info_set_desktop_env desktop_env'+    freeMem desktop_env'+    return ()++
+ GI/Gio/Objects/DesktopAppInfo.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gio.Objects.DesktopAppInfo where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype DesktopAppInfo = DesktopAppInfo (ForeignPtr DesktopAppInfo)+instance GObject DesktopAppInfo where+class GObject o => DesktopAppInfoK o+instance (GObject o, IsDescendantOf DesktopAppInfo o) => DesktopAppInfoK o+data DesktopAppInfoFilenamePropertyInfo
+ GI/Gio/Objects/Emblem.hs view
@@ -0,0 +1,240 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.Emblem+    ( ++-- * Exported types+    Emblem(..)                              ,+    EmblemK                                 ,+    toEmblem                                ,+    noEmblem                                ,+++ -- * Methods+-- ** emblemGetIcon+    emblemGetIcon                           ,+++-- ** emblemGetOrigin+    emblemGetOrigin                         ,+++-- ** emblemNew+    emblemNew                               ,+++-- ** emblemNewWithOrigin+    emblemNewWithOrigin                     ,+++++ -- * Properties+-- ** Icon+    EmblemIconPropertyInfo                  ,+    constructEmblemIcon                     ,+    getEmblemIcon                           ,+++-- ** Origin+    EmblemOriginPropertyInfo                ,+    constructEmblemOrigin                   ,+    getEmblemOrigin                         ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype Emblem = Emblem (ForeignPtr Emblem)+foreign import ccall "g_emblem_get_type"+    c_g_emblem_get_type :: IO GType++type instance ParentTypes Emblem = EmblemParentTypes+type EmblemParentTypes = '[GObject.Object, Icon]++instance GObject Emblem where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_emblem_get_type+    ++class GObject o => EmblemK o+instance (GObject o, IsDescendantOf Emblem o) => EmblemK o++toEmblem :: EmblemK o => o -> IO Emblem+toEmblem = unsafeCastTo Emblem++noEmblem :: Maybe Emblem+noEmblem = Nothing++-- VVV Prop "icon"+   -- Type: TInterface "GObject" "Object"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getEmblemIcon :: (MonadIO m, EmblemK o) => o -> m GObject.Object+getEmblemIcon obj = liftIO $ getObjectPropertyObject obj "icon" GObject.Object++constructEmblemIcon :: (GObject.ObjectK a) => a -> IO ([Char], GValue)+constructEmblemIcon val = constructObjectPropertyObject "icon" val++data EmblemIconPropertyInfo+instance AttrInfo EmblemIconPropertyInfo where+    type AttrAllowedOps EmblemIconPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EmblemIconPropertyInfo = GObject.ObjectK+    type AttrBaseTypeConstraint EmblemIconPropertyInfo = EmblemK+    type AttrGetType EmblemIconPropertyInfo = GObject.Object+    type AttrLabel EmblemIconPropertyInfo = "Emblem::icon"+    attrGet _ = getEmblemIcon+    attrSet _ = undefined+    attrConstruct _ = constructEmblemIcon++-- VVV Prop "origin"+   -- Type: TInterface "Gio" "EmblemOrigin"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getEmblemOrigin :: (MonadIO m, EmblemK o) => o -> m EmblemOrigin+getEmblemOrigin obj = liftIO $ getObjectPropertyEnum obj "origin"++constructEmblemOrigin :: EmblemOrigin -> IO ([Char], GValue)+constructEmblemOrigin val = constructObjectPropertyEnum "origin" val++data EmblemOriginPropertyInfo+instance AttrInfo EmblemOriginPropertyInfo where+    type AttrAllowedOps EmblemOriginPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EmblemOriginPropertyInfo = (~) EmblemOrigin+    type AttrBaseTypeConstraint EmblemOriginPropertyInfo = EmblemK+    type AttrGetType EmblemOriginPropertyInfo = EmblemOrigin+    type AttrLabel EmblemOriginPropertyInfo = "Emblem::origin"+    attrGet _ = getEmblemOrigin+    attrSet _ = undefined+    attrConstruct _ = constructEmblemOrigin++type instance AttributeList Emblem = EmblemAttributeList+type EmblemAttributeList = ('[ '("icon", EmblemIconPropertyInfo), '("origin", EmblemOriginPropertyInfo)] :: [(Symbol, *)])++type instance SignalList Emblem = EmblemSignalList+type EmblemSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Emblem::new+-- method type : Constructor+-- Args : [Arg {argName = "icon", argType = TInterface "Gio" "Icon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "icon", argType = TInterface "Gio" "Icon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Emblem"+-- throws : False+-- Skip return : False++foreign import ccall "g_emblem_new" g_emblem_new :: +    Ptr Icon ->                             -- icon : TInterface "Gio" "Icon"+    IO (Ptr Emblem)+++emblemNew ::+    (MonadIO m, IconK a) =>+    a ->                                    -- icon+    m Emblem+emblemNew icon = liftIO $ do+    let icon' = unsafeManagedPtrCastPtr icon+    result <- g_emblem_new icon'+    checkUnexpectedReturnNULL "g_emblem_new" result+    result' <- (wrapObject Emblem) result+    touchManagedPtr icon+    return result'++-- method Emblem::new_with_origin+-- method type : Constructor+-- Args : [Arg {argName = "icon", argType = TInterface "Gio" "Icon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "origin", argType = TInterface "Gio" "EmblemOrigin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "icon", argType = TInterface "Gio" "Icon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "origin", argType = TInterface "Gio" "EmblemOrigin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Emblem"+-- throws : False+-- Skip return : False++foreign import ccall "g_emblem_new_with_origin" g_emblem_new_with_origin :: +    Ptr Icon ->                             -- icon : TInterface "Gio" "Icon"+    CUInt ->                                -- origin : TInterface "Gio" "EmblemOrigin"+    IO (Ptr Emblem)+++emblemNewWithOrigin ::+    (MonadIO m, IconK a) =>+    a ->                                    -- icon+    EmblemOrigin ->                         -- origin+    m Emblem+emblemNewWithOrigin icon origin = liftIO $ do+    let icon' = unsafeManagedPtrCastPtr icon+    let origin' = (fromIntegral . fromEnum) origin+    result <- g_emblem_new_with_origin icon' origin'+    checkUnexpectedReturnNULL "g_emblem_new_with_origin" result+    result' <- (wrapObject Emblem) result+    touchManagedPtr icon+    return result'++-- method Emblem::get_icon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Emblem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Emblem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Icon"+-- throws : False+-- Skip return : False++foreign import ccall "g_emblem_get_icon" g_emblem_get_icon :: +    Ptr Emblem ->                           -- _obj : TInterface "Gio" "Emblem"+    IO (Ptr Icon)+++emblemGetIcon ::+    (MonadIO m, EmblemK a) =>+    a ->                                    -- _obj+    m Icon+emblemGetIcon _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_emblem_get_icon _obj'+    checkUnexpectedReturnNULL "g_emblem_get_icon" result+    result' <- (newObject Icon) result+    touchManagedPtr _obj+    return result'++-- method Emblem::get_origin+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Emblem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Emblem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "EmblemOrigin"+-- throws : False+-- Skip return : False++foreign import ccall "g_emblem_get_origin" g_emblem_get_origin :: +    Ptr Emblem ->                           -- _obj : TInterface "Gio" "Emblem"+    IO CUInt+++emblemGetOrigin ::+    (MonadIO m, EmblemK a) =>+    a ->                                    -- _obj+    m EmblemOrigin+emblemGetOrigin _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_emblem_get_origin _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++
+ GI/Gio/Objects/Emblem.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gio.Objects.Emblem where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Emblem = Emblem (ForeignPtr Emblem)+instance GObject Emblem where+class GObject o => EmblemK o+instance (GObject o, IsDescendantOf Emblem o) => EmblemK o+data EmblemIconPropertyInfo+data EmblemOriginPropertyInfo
+ GI/Gio/Objects/EmblemedIcon.hs view
@@ -0,0 +1,250 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.EmblemedIcon+    ( ++-- * Exported types+    EmblemedIcon(..)                        ,+    EmblemedIconK                           ,+    toEmblemedIcon                          ,+    noEmblemedIcon                          ,+++ -- * Methods+-- ** emblemedIconAddEmblem+    emblemedIconAddEmblem                   ,+++-- ** emblemedIconClearEmblems+    emblemedIconClearEmblems                ,+++-- ** emblemedIconGetEmblems+    emblemedIconGetEmblems                  ,+++-- ** emblemedIconGetIcon+    emblemedIconGetIcon                     ,+++-- ** emblemedIconNew+    emblemedIconNew                         ,+++++ -- * Properties+-- ** Gicon+    EmblemedIconGiconPropertyInfo           ,+    constructEmblemedIconGicon              ,+    getEmblemedIconGicon                    ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype EmblemedIcon = EmblemedIcon (ForeignPtr EmblemedIcon)+foreign import ccall "g_emblemed_icon_get_type"+    c_g_emblemed_icon_get_type :: IO GType++type instance ParentTypes EmblemedIcon = EmblemedIconParentTypes+type EmblemedIconParentTypes = '[GObject.Object, Icon]++instance GObject EmblemedIcon where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_emblemed_icon_get_type+    ++class GObject o => EmblemedIconK o+instance (GObject o, IsDescendantOf EmblemedIcon o) => EmblemedIconK o++toEmblemedIcon :: EmblemedIconK o => o -> IO EmblemedIcon+toEmblemedIcon = unsafeCastTo EmblemedIcon++noEmblemedIcon :: Maybe EmblemedIcon+noEmblemedIcon = Nothing++-- VVV Prop "gicon"+   -- Type: TInterface "Gio" "Icon"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getEmblemedIconGicon :: (MonadIO m, EmblemedIconK o) => o -> m Icon+getEmblemedIconGicon obj = liftIO $ getObjectPropertyObject obj "gicon" Icon++constructEmblemedIconGicon :: (IconK a) => a -> IO ([Char], GValue)+constructEmblemedIconGicon val = constructObjectPropertyObject "gicon" val++data EmblemedIconGiconPropertyInfo+instance AttrInfo EmblemedIconGiconPropertyInfo where+    type AttrAllowedOps EmblemedIconGiconPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EmblemedIconGiconPropertyInfo = IconK+    type AttrBaseTypeConstraint EmblemedIconGiconPropertyInfo = EmblemedIconK+    type AttrGetType EmblemedIconGiconPropertyInfo = Icon+    type AttrLabel EmblemedIconGiconPropertyInfo = "EmblemedIcon::gicon"+    attrGet _ = getEmblemedIconGicon+    attrSet _ = undefined+    attrConstruct _ = constructEmblemedIconGicon++type instance AttributeList EmblemedIcon = EmblemedIconAttributeList+type EmblemedIconAttributeList = ('[ '("gicon", EmblemedIconGiconPropertyInfo)] :: [(Symbol, *)])++type instance SignalList EmblemedIcon = EmblemedIconSignalList+type EmblemedIconSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method EmblemedIcon::new+-- method type : Constructor+-- Args : [Arg {argName = "icon", argType = TInterface "Gio" "Icon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "emblem", argType = TInterface "Gio" "Emblem", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "icon", argType = TInterface "Gio" "Icon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "emblem", argType = TInterface "Gio" "Emblem", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "EmblemedIcon"+-- throws : False+-- Skip return : False++foreign import ccall "g_emblemed_icon_new" g_emblemed_icon_new :: +    Ptr Icon ->                             -- icon : TInterface "Gio" "Icon"+    Ptr Emblem ->                           -- emblem : TInterface "Gio" "Emblem"+    IO (Ptr EmblemedIcon)+++emblemedIconNew ::+    (MonadIO m, IconK a, EmblemK b) =>+    a ->                                    -- icon+    Maybe (b) ->                            -- emblem+    m EmblemedIcon+emblemedIconNew icon emblem = liftIO $ do+    let icon' = unsafeManagedPtrCastPtr icon+    maybeEmblem <- case emblem of+        Nothing -> return nullPtr+        Just jEmblem -> do+            let jEmblem' = unsafeManagedPtrCastPtr jEmblem+            return jEmblem'+    result <- g_emblemed_icon_new icon' maybeEmblem+    checkUnexpectedReturnNULL "g_emblemed_icon_new" result+    result' <- (wrapObject EmblemedIcon) result+    touchManagedPtr icon+    whenJust emblem touchManagedPtr+    return result'++-- method EmblemedIcon::add_emblem+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "EmblemedIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "emblem", argType = TInterface "Gio" "Emblem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "EmblemedIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "emblem", argType = TInterface "Gio" "Emblem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_emblemed_icon_add_emblem" g_emblemed_icon_add_emblem :: +    Ptr EmblemedIcon ->                     -- _obj : TInterface "Gio" "EmblemedIcon"+    Ptr Emblem ->                           -- emblem : TInterface "Gio" "Emblem"+    IO ()+++emblemedIconAddEmblem ::+    (MonadIO m, EmblemedIconK a, EmblemK b) =>+    a ->                                    -- _obj+    b ->                                    -- emblem+    m ()+emblemedIconAddEmblem _obj emblem = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let emblem' = unsafeManagedPtrCastPtr emblem+    g_emblemed_icon_add_emblem _obj' emblem'+    touchManagedPtr _obj+    touchManagedPtr emblem+    return ()++-- method EmblemedIcon::clear_emblems+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "EmblemedIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "EmblemedIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_emblemed_icon_clear_emblems" g_emblemed_icon_clear_emblems :: +    Ptr EmblemedIcon ->                     -- _obj : TInterface "Gio" "EmblemedIcon"+    IO ()+++emblemedIconClearEmblems ::+    (MonadIO m, EmblemedIconK a) =>+    a ->                                    -- _obj+    m ()+emblemedIconClearEmblems _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_emblemed_icon_clear_emblems _obj'+    touchManagedPtr _obj+    return ()++-- method EmblemedIcon::get_emblems+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "EmblemedIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "EmblemedIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gio" "Emblem")+-- throws : False+-- Skip return : False++foreign import ccall "g_emblemed_icon_get_emblems" g_emblemed_icon_get_emblems :: +    Ptr EmblemedIcon ->                     -- _obj : TInterface "Gio" "EmblemedIcon"+    IO (Ptr (GList (Ptr Emblem)))+++emblemedIconGetEmblems ::+    (MonadIO m, EmblemedIconK a) =>+    a ->                                    -- _obj+    m [Emblem]+emblemedIconGetEmblems _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_emblemed_icon_get_emblems _obj'+    checkUnexpectedReturnNULL "g_emblemed_icon_get_emblems" result+    result' <- unpackGList result+    result'' <- mapM (newObject Emblem) result'+    touchManagedPtr _obj+    return result''++-- method EmblemedIcon::get_icon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "EmblemedIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "EmblemedIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Icon"+-- throws : False+-- Skip return : False++foreign import ccall "g_emblemed_icon_get_icon" g_emblemed_icon_get_icon :: +    Ptr EmblemedIcon ->                     -- _obj : TInterface "Gio" "EmblemedIcon"+    IO (Ptr Icon)+++emblemedIconGetIcon ::+    (MonadIO m, EmblemedIconK a) =>+    a ->                                    -- _obj+    m Icon+emblemedIconGetIcon _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_emblemed_icon_get_icon _obj'+    checkUnexpectedReturnNULL "g_emblemed_icon_get_icon" result+    result' <- (newObject Icon) result+    touchManagedPtr _obj+    return result'++
+ GI/Gio/Objects/EmblemedIcon.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gio.Objects.EmblemedIcon where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype EmblemedIcon = EmblemedIcon (ForeignPtr EmblemedIcon)+instance GObject EmblemedIcon where+class GObject o => EmblemedIconK o+instance (GObject o, IsDescendantOf EmblemedIcon o) => EmblemedIconK o+data EmblemedIconGiconPropertyInfo
+ GI/Gio/Objects/FileEnumerator.hs view
@@ -0,0 +1,554 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.FileEnumerator+    ( ++-- * Exported types+    FileEnumerator(..)                      ,+    FileEnumeratorK                         ,+    toFileEnumerator                        ,+    noFileEnumerator                        ,+++ -- * Methods+-- ** fileEnumeratorClose+    fileEnumeratorClose                     ,+++-- ** fileEnumeratorCloseAsync+    fileEnumeratorCloseAsync                ,+++-- ** fileEnumeratorCloseFinish+    fileEnumeratorCloseFinish               ,+++-- ** fileEnumeratorGetChild+    fileEnumeratorGetChild                  ,+++-- ** fileEnumeratorGetContainer+    fileEnumeratorGetContainer              ,+++-- ** fileEnumeratorHasPending+    fileEnumeratorHasPending                ,+++-- ** fileEnumeratorIsClosed+    fileEnumeratorIsClosed                  ,+++-- ** fileEnumeratorIterate+    fileEnumeratorIterate                   ,+++-- ** fileEnumeratorNextFile+    fileEnumeratorNextFile                  ,+++-- ** fileEnumeratorNextFilesAsync+    fileEnumeratorNextFilesAsync            ,+++-- ** fileEnumeratorNextFilesFinish+    fileEnumeratorNextFilesFinish           ,+++-- ** fileEnumeratorSetPending+    fileEnumeratorSetPending                ,+++++ -- * Properties+-- ** Container+    FileEnumeratorContainerPropertyInfo     ,+    constructFileEnumeratorContainer        ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype FileEnumerator = FileEnumerator (ForeignPtr FileEnumerator)+foreign import ccall "g_file_enumerator_get_type"+    c_g_file_enumerator_get_type :: IO GType++type instance ParentTypes FileEnumerator = FileEnumeratorParentTypes+type FileEnumeratorParentTypes = '[GObject.Object]++instance GObject FileEnumerator where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_file_enumerator_get_type+    ++class GObject o => FileEnumeratorK o+instance (GObject o, IsDescendantOf FileEnumerator o) => FileEnumeratorK o++toFileEnumerator :: FileEnumeratorK o => o -> IO FileEnumerator+toFileEnumerator = unsafeCastTo FileEnumerator++noFileEnumerator :: Maybe FileEnumerator+noFileEnumerator = Nothing++-- VVV Prop "container"+   -- Type: TInterface "Gio" "File"+   -- Flags: [PropertyWritable,PropertyConstructOnly]++constructFileEnumeratorContainer :: (FileK a) => a -> IO ([Char], GValue)+constructFileEnumeratorContainer val = constructObjectPropertyObject "container" val++data FileEnumeratorContainerPropertyInfo+instance AttrInfo FileEnumeratorContainerPropertyInfo where+    type AttrAllowedOps FileEnumeratorContainerPropertyInfo = '[ 'AttrConstruct]+    type AttrSetTypeConstraint FileEnumeratorContainerPropertyInfo = FileK+    type AttrBaseTypeConstraint FileEnumeratorContainerPropertyInfo = FileEnumeratorK+    type AttrGetType FileEnumeratorContainerPropertyInfo = ()+    type AttrLabel FileEnumeratorContainerPropertyInfo = "FileEnumerator::container"+    attrGet _ = undefined+    attrSet _ = undefined+    attrConstruct _ = constructFileEnumeratorContainer++type instance AttributeList FileEnumerator = FileEnumeratorAttributeList+type FileEnumeratorAttributeList = ('[ '("container", FileEnumeratorContainerPropertyInfo)] :: [(Symbol, *)])++type instance SignalList FileEnumerator = FileEnumeratorSignalList+type FileEnumeratorSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method FileEnumerator::close+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileEnumerator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileEnumerator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_enumerator_close" g_file_enumerator_close :: +    Ptr FileEnumerator ->                   -- _obj : TInterface "Gio" "FileEnumerator"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileEnumeratorClose ::+    (MonadIO m, FileEnumeratorK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m ()+fileEnumeratorClose _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_file_enumerator_close _obj' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method FileEnumerator::close_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileEnumerator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileEnumerator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_enumerator_close_async" g_file_enumerator_close_async :: +    Ptr FileEnumerator ->                   -- _obj : TInterface "Gio" "FileEnumerator"+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++fileEnumeratorCloseAsync ::+    (MonadIO m, FileEnumeratorK a, CancellableK b) =>+    a ->                                    -- _obj+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+fileEnumeratorCloseAsync _obj io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_file_enumerator_close_async _obj' io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method FileEnumerator::close_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileEnumerator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileEnumerator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_enumerator_close_finish" g_file_enumerator_close_finish :: +    Ptr FileEnumerator ->                   -- _obj : TInterface "Gio" "FileEnumerator"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileEnumeratorCloseFinish ::+    (MonadIO m, FileEnumeratorK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+fileEnumeratorCloseFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_file_enumerator_close_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++-- method FileEnumerator::get_child+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileEnumerator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "info", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileEnumerator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "info", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "File"+-- throws : False+-- Skip return : False++foreign import ccall "g_file_enumerator_get_child" g_file_enumerator_get_child :: +    Ptr FileEnumerator ->                   -- _obj : TInterface "Gio" "FileEnumerator"+    Ptr FileInfo ->                         -- info : TInterface "Gio" "FileInfo"+    IO (Ptr File)+++fileEnumeratorGetChild ::+    (MonadIO m, FileEnumeratorK a, FileInfoK b) =>+    a ->                                    -- _obj+    b ->                                    -- info+    m File+fileEnumeratorGetChild _obj info = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let info' = unsafeManagedPtrCastPtr info+    result <- g_file_enumerator_get_child _obj' info'+    checkUnexpectedReturnNULL "g_file_enumerator_get_child" result+    result' <- (wrapObject File) result+    touchManagedPtr _obj+    touchManagedPtr info+    return result'++-- method FileEnumerator::get_container+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileEnumerator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileEnumerator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "File"+-- throws : False+-- Skip return : False++foreign import ccall "g_file_enumerator_get_container" g_file_enumerator_get_container :: +    Ptr FileEnumerator ->                   -- _obj : TInterface "Gio" "FileEnumerator"+    IO (Ptr File)+++fileEnumeratorGetContainer ::+    (MonadIO m, FileEnumeratorK a) =>+    a ->                                    -- _obj+    m File+fileEnumeratorGetContainer _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_enumerator_get_container _obj'+    checkUnexpectedReturnNULL "g_file_enumerator_get_container" result+    result' <- (newObject File) result+    touchManagedPtr _obj+    return result'++-- method FileEnumerator::has_pending+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileEnumerator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileEnumerator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_file_enumerator_has_pending" g_file_enumerator_has_pending :: +    Ptr FileEnumerator ->                   -- _obj : TInterface "Gio" "FileEnumerator"+    IO CInt+++fileEnumeratorHasPending ::+    (MonadIO m, FileEnumeratorK a) =>+    a ->                                    -- _obj+    m Bool+fileEnumeratorHasPending _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_enumerator_has_pending _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FileEnumerator::is_closed+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileEnumerator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileEnumerator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_file_enumerator_is_closed" g_file_enumerator_is_closed :: +    Ptr FileEnumerator ->                   -- _obj : TInterface "Gio" "FileEnumerator"+    IO CInt+++fileEnumeratorIsClosed ::+    (MonadIO m, FileEnumeratorK a) =>+    a ->                                    -- _obj+    m Bool+fileEnumeratorIsClosed _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_enumerator_is_closed _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FileEnumerator::iterate+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileEnumerator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "out_info", argType = TInterface "Gio" "FileInfo", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "out_child", argType = TInterface "Gio" "File", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileEnumerator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_file_enumerator_iterate" g_file_enumerator_iterate :: +    Ptr FileEnumerator ->                   -- _obj : TInterface "Gio" "FileEnumerator"+    Ptr (Ptr FileInfo) ->                   -- out_info : TInterface "Gio" "FileInfo"+    Ptr (Ptr File) ->                       -- out_child : TInterface "Gio" "File"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileEnumeratorIterate ::+    (MonadIO m, FileEnumeratorK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m (FileInfo,File)+fileEnumeratorIterate _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    out_info <- allocMem :: IO (Ptr (Ptr FileInfo))+    out_child <- allocMem :: IO (Ptr (Ptr File))+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_file_enumerator_iterate _obj' out_info out_child maybeCancellable+        out_info' <- peek out_info+        out_info'' <- (newObject FileInfo) out_info'+        out_child' <- peek out_child+        out_child'' <- (newObject File) out_child'+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem out_info+        freeMem out_child+        return (out_info'', out_child'')+     ) (do+        freeMem out_info+        freeMem out_child+     )++-- method FileEnumerator::next_file+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileEnumerator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileEnumerator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileInfo"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_enumerator_next_file" g_file_enumerator_next_file :: +    Ptr FileEnumerator ->                   -- _obj : TInterface "Gio" "FileEnumerator"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr FileInfo)+++fileEnumeratorNextFile ::+    (MonadIO m, FileEnumeratorK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m FileInfo+fileEnumeratorNextFile _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_file_enumerator_next_file _obj' maybeCancellable+        checkUnexpectedReturnNULL "g_file_enumerator_next_file" result+        result' <- (wrapObject FileInfo) result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )++-- method FileEnumerator::next_files_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileEnumerator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "num_files", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileEnumerator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "num_files", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_enumerator_next_files_async" g_file_enumerator_next_files_async :: +    Ptr FileEnumerator ->                   -- _obj : TInterface "Gio" "FileEnumerator"+    Int32 ->                                -- num_files : TBasicType TInt32+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++fileEnumeratorNextFilesAsync ::+    (MonadIO m, FileEnumeratorK a, CancellableK b) =>+    a ->                                    -- _obj+    Int32 ->                                -- num_files+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+fileEnumeratorNextFilesAsync _obj num_files io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_file_enumerator_next_files_async _obj' num_files io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method FileEnumerator::next_files_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileEnumerator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileEnumerator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gio" "FileInfo")+-- throws : True+-- Skip return : False++foreign import ccall "g_file_enumerator_next_files_finish" g_file_enumerator_next_files_finish :: +    Ptr FileEnumerator ->                   -- _obj : TInterface "Gio" "FileEnumerator"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr (GList (Ptr FileInfo)))+++fileEnumeratorNextFilesFinish ::+    (MonadIO m, FileEnumeratorK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m [FileInfo]+fileEnumeratorNextFilesFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        result <- propagateGError $ g_file_enumerator_next_files_finish _obj' result_'+        checkUnexpectedReturnNULL "g_file_enumerator_next_files_finish" result+        result' <- unpackGList result+        result'' <- mapM (wrapObject FileInfo) result'+        g_list_free result+        touchManagedPtr _obj+        touchManagedPtr result_+        return result''+     ) (do+        return ()+     )++-- method FileEnumerator::set_pending+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileEnumerator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pending", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileEnumerator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pending", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_enumerator_set_pending" g_file_enumerator_set_pending :: +    Ptr FileEnumerator ->                   -- _obj : TInterface "Gio" "FileEnumerator"+    CInt ->                                 -- pending : TBasicType TBoolean+    IO ()+++fileEnumeratorSetPending ::+    (MonadIO m, FileEnumeratorK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- pending+    m ()+fileEnumeratorSetPending _obj pending = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let pending' = (fromIntegral . fromEnum) pending+    g_file_enumerator_set_pending _obj' pending'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Objects/FileEnumerator.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gio.Objects.FileEnumerator where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype FileEnumerator = FileEnumerator (ForeignPtr FileEnumerator)+instance GObject FileEnumerator where+class GObject o => FileEnumeratorK o+instance (GObject o, IsDescendantOf FileEnumerator o) => FileEnumeratorK o+data FileEnumeratorContainerPropertyInfo
+ GI/Gio/Objects/FileIOStream.hs view
@@ -0,0 +1,231 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.FileIOStream+    ( ++-- * Exported types+    FileIOStream(..)                        ,+    FileIOStreamK                           ,+    toFileIOStream                          ,+    noFileIOStream                          ,+++ -- * Methods+-- ** fileIOStreamGetEtag+    fileIOStreamGetEtag                     ,+++-- ** fileIOStreamQueryInfo+    fileIOStreamQueryInfo                   ,+++-- ** fileIOStreamQueryInfoAsync+    fileIOStreamQueryInfoAsync              ,+++-- ** fileIOStreamQueryInfoFinish+    fileIOStreamQueryInfoFinish             ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype FileIOStream = FileIOStream (ForeignPtr FileIOStream)+foreign import ccall "g_file_io_stream_get_type"+    c_g_file_io_stream_get_type :: IO GType++type instance ParentTypes FileIOStream = FileIOStreamParentTypes+type FileIOStreamParentTypes = '[IOStream, GObject.Object, Seekable]++instance GObject FileIOStream where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_file_io_stream_get_type+    ++class GObject o => FileIOStreamK o+instance (GObject o, IsDescendantOf FileIOStream o) => FileIOStreamK o++toFileIOStream :: FileIOStreamK o => o -> IO FileIOStream+toFileIOStream = unsafeCastTo FileIOStream++noFileIOStream :: Maybe FileIOStream+noFileIOStream = Nothing++type instance AttributeList FileIOStream = FileIOStreamAttributeList+type FileIOStreamAttributeList = ('[ '("closed", IOStreamClosedPropertyInfo), '("input-stream", IOStreamInputStreamPropertyInfo), '("output-stream", IOStreamOutputStreamPropertyInfo)] :: [(Symbol, *)])++type instance SignalList FileIOStream = FileIOStreamSignalList+type FileIOStreamSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method FileIOStream::get_etag+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileIOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileIOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_file_io_stream_get_etag" g_file_io_stream_get_etag :: +    Ptr FileIOStream ->                     -- _obj : TInterface "Gio" "FileIOStream"+    IO CString+++fileIOStreamGetEtag ::+    (MonadIO m, FileIOStreamK a) =>+    a ->                                    -- _obj+    m T.Text+fileIOStreamGetEtag _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_io_stream_get_etag _obj'+    checkUnexpectedReturnNULL "g_file_io_stream_get_etag" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method FileIOStream::query_info+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileIOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attributes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileIOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attributes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileInfo"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_io_stream_query_info" g_file_io_stream_query_info :: +    Ptr FileIOStream ->                     -- _obj : TInterface "Gio" "FileIOStream"+    CString ->                              -- attributes : TBasicType TUTF8+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr FileInfo)+++fileIOStreamQueryInfo ::+    (MonadIO m, FileIOStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- attributes+    Maybe (b) ->                            -- cancellable+    m FileInfo+fileIOStreamQueryInfo _obj attributes cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attributes' <- textToCString attributes+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_file_io_stream_query_info _obj' attributes' maybeCancellable+        checkUnexpectedReturnNULL "g_file_io_stream_query_info" result+        result' <- (wrapObject FileInfo) result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem attributes'+        return result'+     ) (do+        freeMem attributes'+     )++-- method FileIOStream::query_info_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileIOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attributes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileIOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attributes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_io_stream_query_info_async" g_file_io_stream_query_info_async :: +    Ptr FileIOStream ->                     -- _obj : TInterface "Gio" "FileIOStream"+    CString ->                              -- attributes : TBasicType TUTF8+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++fileIOStreamQueryInfoAsync ::+    (MonadIO m, FileIOStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- attributes+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+fileIOStreamQueryInfoAsync _obj attributes io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attributes' <- textToCString attributes+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_file_io_stream_query_info_async _obj' attributes' io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    freeMem attributes'+    return ()++-- method FileIOStream::query_info_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileIOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileIOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileInfo"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_io_stream_query_info_finish" g_file_io_stream_query_info_finish :: +    Ptr FileIOStream ->                     -- _obj : TInterface "Gio" "FileIOStream"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr FileInfo)+++fileIOStreamQueryInfoFinish ::+    (MonadIO m, FileIOStreamK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m FileInfo+fileIOStreamQueryInfoFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        result <- propagateGError $ g_file_io_stream_query_info_finish _obj' result_'+        checkUnexpectedReturnNULL "g_file_io_stream_query_info_finish" result+        result' <- (wrapObject FileInfo) result+        touchManagedPtr _obj+        touchManagedPtr result_+        return result'+     ) (do+        return ()+     )++
+ GI/Gio/Objects/FileIOStream.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Objects.FileIOStream where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype FileIOStream = FileIOStream (ForeignPtr FileIOStream)+instance GObject FileIOStream where+class GObject o => FileIOStreamK o+instance (GObject o, IsDescendantOf FileIOStream o) => FileIOStreamK o
+ GI/Gio/Objects/FileIcon.hs view
@@ -0,0 +1,151 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.FileIcon+    ( ++-- * Exported types+    FileIcon(..)                            ,+    FileIconK                               ,+    toFileIcon                              ,+    noFileIcon                              ,+++ -- * Methods+-- ** fileIconGetFile+    fileIconGetFile                         ,+++-- ** fileIconNew+    fileIconNew                             ,+++++ -- * Properties+-- ** File+    FileIconFilePropertyInfo                ,+    constructFileIconFile                   ,+    getFileIconFile                         ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype FileIcon = FileIcon (ForeignPtr FileIcon)+foreign import ccall "g_file_icon_get_type"+    c_g_file_icon_get_type :: IO GType++type instance ParentTypes FileIcon = FileIconParentTypes+type FileIconParentTypes = '[GObject.Object, Icon, LoadableIcon]++instance GObject FileIcon where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_file_icon_get_type+    ++class GObject o => FileIconK o+instance (GObject o, IsDescendantOf FileIcon o) => FileIconK o++toFileIcon :: FileIconK o => o -> IO FileIcon+toFileIcon = unsafeCastTo FileIcon++noFileIcon :: Maybe FileIcon+noFileIcon = Nothing++-- VVV Prop "file"+   -- Type: TInterface "Gio" "File"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getFileIconFile :: (MonadIO m, FileIconK o) => o -> m File+getFileIconFile obj = liftIO $ getObjectPropertyObject obj "file" File++constructFileIconFile :: (FileK a) => a -> IO ([Char], GValue)+constructFileIconFile val = constructObjectPropertyObject "file" val++data FileIconFilePropertyInfo+instance AttrInfo FileIconFilePropertyInfo where+    type AttrAllowedOps FileIconFilePropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FileIconFilePropertyInfo = FileK+    type AttrBaseTypeConstraint FileIconFilePropertyInfo = FileIconK+    type AttrGetType FileIconFilePropertyInfo = File+    type AttrLabel FileIconFilePropertyInfo = "FileIcon::file"+    attrGet _ = getFileIconFile+    attrSet _ = undefined+    attrConstruct _ = constructFileIconFile++type instance AttributeList FileIcon = FileIconAttributeList+type FileIconAttributeList = ('[ '("file", FileIconFilePropertyInfo)] :: [(Symbol, *)])++type instance SignalList FileIcon = FileIconSignalList+type FileIconSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method FileIcon::new+-- method type : Constructor+-- Args : [Arg {argName = "file", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "file", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileIcon"+-- throws : False+-- Skip return : False++foreign import ccall "g_file_icon_new" g_file_icon_new :: +    Ptr File ->                             -- file : TInterface "Gio" "File"+    IO (Ptr FileIcon)+++fileIconNew ::+    (MonadIO m, FileK a) =>+    a ->                                    -- file+    m FileIcon+fileIconNew file = liftIO $ do+    let file' = unsafeManagedPtrCastPtr file+    result <- g_file_icon_new file'+    checkUnexpectedReturnNULL "g_file_icon_new" result+    result' <- (wrapObject FileIcon) result+    touchManagedPtr file+    return result'++-- method FileIcon::get_file+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "File"+-- throws : False+-- Skip return : False++foreign import ccall "g_file_icon_get_file" g_file_icon_get_file :: +    Ptr FileIcon ->                         -- _obj : TInterface "Gio" "FileIcon"+    IO (Ptr File)+++fileIconGetFile ::+    (MonadIO m, FileIconK a) =>+    a ->                                    -- _obj+    m File+fileIconGetFile _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_icon_get_file _obj'+    checkUnexpectedReturnNULL "g_file_icon_get_file" result+    result' <- (newObject File) result+    touchManagedPtr _obj+    return result'++
+ GI/Gio/Objects/FileIcon.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gio.Objects.FileIcon where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype FileIcon = FileIcon (ForeignPtr FileIcon)+instance GObject FileIcon where+class GObject o => FileIconK o+instance (GObject o, IsDescendantOf FileIcon o) => FileIconK o+data FileIconFilePropertyInfo
+ GI/Gio/Objects/FileInfo.hs view
@@ -0,0 +1,2085 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.FileInfo+    ( ++-- * Exported types+    FileInfo(..)                            ,+    FileInfoK                               ,+    toFileInfo                              ,+    noFileInfo                              ,+++ -- * Methods+-- ** fileInfoClearStatus+    fileInfoClearStatus                     ,+++-- ** fileInfoCopyInto+    fileInfoCopyInto                        ,+++-- ** fileInfoDup+    fileInfoDup                             ,+++-- ** fileInfoGetAttributeAsString+    fileInfoGetAttributeAsString            ,+++-- ** fileInfoGetAttributeBoolean+    fileInfoGetAttributeBoolean             ,+++-- ** fileInfoGetAttributeByteString+    fileInfoGetAttributeByteString          ,+++-- ** fileInfoGetAttributeData+    fileInfoGetAttributeData                ,+++-- ** fileInfoGetAttributeInt32+    fileInfoGetAttributeInt32               ,+++-- ** fileInfoGetAttributeInt64+    fileInfoGetAttributeInt64               ,+++-- ** fileInfoGetAttributeObject+    fileInfoGetAttributeObject              ,+++-- ** fileInfoGetAttributeStatus+    fileInfoGetAttributeStatus              ,+++-- ** fileInfoGetAttributeString+    fileInfoGetAttributeString              ,+++-- ** fileInfoGetAttributeStringv+    fileInfoGetAttributeStringv             ,+++-- ** fileInfoGetAttributeType+    fileInfoGetAttributeType                ,+++-- ** fileInfoGetAttributeUint32+    fileInfoGetAttributeUint32              ,+++-- ** fileInfoGetAttributeUint64+    fileInfoGetAttributeUint64              ,+++-- ** fileInfoGetContentType+    fileInfoGetContentType                  ,+++-- ** fileInfoGetDeletionDate+    fileInfoGetDeletionDate                 ,+++-- ** fileInfoGetDisplayName+    fileInfoGetDisplayName                  ,+++-- ** fileInfoGetEditName+    fileInfoGetEditName                     ,+++-- ** fileInfoGetEtag+    fileInfoGetEtag                         ,+++-- ** fileInfoGetFileType+    fileInfoGetFileType                     ,+++-- ** fileInfoGetIcon+    fileInfoGetIcon                         ,+++-- ** fileInfoGetIsBackup+    fileInfoGetIsBackup                     ,+++-- ** fileInfoGetIsHidden+    fileInfoGetIsHidden                     ,+++-- ** fileInfoGetIsSymlink+    fileInfoGetIsSymlink                    ,+++-- ** fileInfoGetModificationTime+    fileInfoGetModificationTime             ,+++-- ** fileInfoGetName+    fileInfoGetName                         ,+++-- ** fileInfoGetSize+    fileInfoGetSize                         ,+++-- ** fileInfoGetSortOrder+    fileInfoGetSortOrder                    ,+++-- ** fileInfoGetSymbolicIcon+    fileInfoGetSymbolicIcon                 ,+++-- ** fileInfoGetSymlinkTarget+    fileInfoGetSymlinkTarget                ,+++-- ** fileInfoHasAttribute+    fileInfoHasAttribute                    ,+++-- ** fileInfoHasNamespace+    fileInfoHasNamespace                    ,+++-- ** fileInfoListAttributes+    fileInfoListAttributes                  ,+++-- ** fileInfoNew+    fileInfoNew                             ,+++-- ** fileInfoRemoveAttribute+    fileInfoRemoveAttribute                 ,+++-- ** fileInfoSetAttribute+    fileInfoSetAttribute                    ,+++-- ** fileInfoSetAttributeBoolean+    fileInfoSetAttributeBoolean             ,+++-- ** fileInfoSetAttributeByteString+    fileInfoSetAttributeByteString          ,+++-- ** fileInfoSetAttributeInt32+    fileInfoSetAttributeInt32               ,+++-- ** fileInfoSetAttributeInt64+    fileInfoSetAttributeInt64               ,+++-- ** fileInfoSetAttributeMask+    fileInfoSetAttributeMask                ,+++-- ** fileInfoSetAttributeObject+    fileInfoSetAttributeObject              ,+++-- ** fileInfoSetAttributeStatus+    fileInfoSetAttributeStatus              ,+++-- ** fileInfoSetAttributeString+    fileInfoSetAttributeString              ,+++-- ** fileInfoSetAttributeStringv+    fileInfoSetAttributeStringv             ,+++-- ** fileInfoSetAttributeUint32+    fileInfoSetAttributeUint32              ,+++-- ** fileInfoSetAttributeUint64+    fileInfoSetAttributeUint64              ,+++-- ** fileInfoSetContentType+    fileInfoSetContentType                  ,+++-- ** fileInfoSetDisplayName+    fileInfoSetDisplayName                  ,+++-- ** fileInfoSetEditName+    fileInfoSetEditName                     ,+++-- ** fileInfoSetFileType+    fileInfoSetFileType                     ,+++-- ** fileInfoSetIcon+    fileInfoSetIcon                         ,+++-- ** fileInfoSetIsHidden+    fileInfoSetIsHidden                     ,+++-- ** fileInfoSetIsSymlink+    fileInfoSetIsSymlink                    ,+++-- ** fileInfoSetModificationTime+    fileInfoSetModificationTime             ,+++-- ** fileInfoSetName+    fileInfoSetName                         ,+++-- ** fileInfoSetSize+    fileInfoSetSize                         ,+++-- ** fileInfoSetSortOrder+    fileInfoSetSortOrder                    ,+++-- ** fileInfoSetSymbolicIcon+    fileInfoSetSymbolicIcon                 ,+++-- ** fileInfoSetSymlinkTarget+    fileInfoSetSymlinkTarget                ,+++-- ** fileInfoUnsetAttributeMask+    fileInfoUnsetAttributeMask              ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype FileInfo = FileInfo (ForeignPtr FileInfo)+foreign import ccall "g_file_info_get_type"+    c_g_file_info_get_type :: IO GType++type instance ParentTypes FileInfo = FileInfoParentTypes+type FileInfoParentTypes = '[GObject.Object]++instance GObject FileInfo where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_file_info_get_type+    ++class GObject o => FileInfoK o+instance (GObject o, IsDescendantOf FileInfo o) => FileInfoK o++toFileInfo :: FileInfoK o => o -> IO FileInfo+toFileInfo = unsafeCastTo FileInfo++noFileInfo :: Maybe FileInfo+noFileInfo = Nothing++type instance AttributeList FileInfo = FileInfoAttributeList+type FileInfoAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList FileInfo = FileInfoSignalList+type FileInfoSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method FileInfo::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gio" "FileInfo"+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_new" g_file_info_new :: +    IO (Ptr FileInfo)+++fileInfoNew ::+    (MonadIO m) =>+    m FileInfo+fileInfoNew  = liftIO $ do+    result <- g_file_info_new+    checkUnexpectedReturnNULL "g_file_info_new" result+    result' <- (wrapObject FileInfo) result+    return result'++-- method FileInfo::clear_status+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_clear_status" g_file_info_clear_status :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    IO ()+++fileInfoClearStatus ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    m ()+fileInfoClearStatus _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_file_info_clear_status _obj'+    touchManagedPtr _obj+    return ()++-- method FileInfo::copy_into+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "dest_info", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "dest_info", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_copy_into" g_file_info_copy_into :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    Ptr FileInfo ->                         -- dest_info : TInterface "Gio" "FileInfo"+    IO ()+++fileInfoCopyInto ::+    (MonadIO m, FileInfoK a, FileInfoK b) =>+    a ->                                    -- _obj+    b ->                                    -- dest_info+    m ()+fileInfoCopyInto _obj dest_info = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let dest_info' = unsafeManagedPtrCastPtr dest_info+    g_file_info_copy_into _obj' dest_info'+    touchManagedPtr _obj+    touchManagedPtr dest_info+    return ()++-- method FileInfo::dup+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileInfo"+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_dup" g_file_info_dup :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    IO (Ptr FileInfo)+++fileInfoDup ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    m FileInfo+fileInfoDup _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_info_dup _obj'+    checkUnexpectedReturnNULL "g_file_info_dup" result+    result' <- (wrapObject FileInfo) result+    touchManagedPtr _obj+    return result'++-- method FileInfo::get_attribute_as_string+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_get_attribute_as_string" g_file_info_get_attribute_as_string :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CString ->                              -- attribute : TBasicType TUTF8+    IO CString+++fileInfoGetAttributeAsString ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    m T.Text+fileInfoGetAttributeAsString _obj attribute = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    result <- g_file_info_get_attribute_as_string _obj' attribute'+    checkUnexpectedReturnNULL "g_file_info_get_attribute_as_string" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    freeMem attribute'+    return result'++-- method FileInfo::get_attribute_boolean+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_get_attribute_boolean" g_file_info_get_attribute_boolean :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CString ->                              -- attribute : TBasicType TUTF8+    IO CInt+++fileInfoGetAttributeBoolean ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    m Bool+fileInfoGetAttributeBoolean _obj attribute = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    result <- g_file_info_get_attribute_boolean _obj' attribute'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem attribute'+    return result'++-- method FileInfo::get_attribute_byte_string+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_get_attribute_byte_string" g_file_info_get_attribute_byte_string :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CString ->                              -- attribute : TBasicType TUTF8+    IO CString+++fileInfoGetAttributeByteString ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    m T.Text+fileInfoGetAttributeByteString _obj attribute = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    result <- g_file_info_get_attribute_byte_string _obj' attribute'+    checkUnexpectedReturnNULL "g_file_info_get_attribute_byte_string" result+    result' <- cstringToText result+    touchManagedPtr _obj+    freeMem attribute'+    return result'++-- method FileInfo::get_attribute_data+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "Gio" "FileAttributeType", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "value_pp", argType = TBasicType TVoid, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "status", argType = TInterface "Gio" "FileAttributeStatus", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_get_attribute_data" g_file_info_get_attribute_data :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CString ->                              -- attribute : TBasicType TUTF8+    Ptr CUInt ->                            -- type : TInterface "Gio" "FileAttributeType"+    Ptr (Ptr ()) ->                         -- value_pp : TBasicType TVoid+    Ptr CUInt ->                            -- status : TInterface "Gio" "FileAttributeStatus"+    IO CInt+++fileInfoGetAttributeData ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    m (Bool,FileAttributeType,(Ptr ()),FileAttributeStatus)+fileInfoGetAttributeData _obj attribute = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    type_ <- allocMem :: IO (Ptr CUInt)+    value_pp <- allocMem :: IO (Ptr (Ptr ()))+    status <- allocMem :: IO (Ptr CUInt)+    result <- g_file_info_get_attribute_data _obj' attribute' type_ value_pp status+    let result' = (/= 0) result+    type_' <- peek type_+    let type_'' = (toEnum . fromIntegral) type_'+    value_pp' <- peek value_pp+    status' <- peek status+    let status'' = (toEnum . fromIntegral) status'+    touchManagedPtr _obj+    freeMem attribute'+    freeMem type_+    freeMem value_pp+    freeMem status+    return (result', type_'', value_pp', status'')++-- method FileInfo::get_attribute_int32+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_get_attribute_int32" g_file_info_get_attribute_int32 :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CString ->                              -- attribute : TBasicType TUTF8+    IO Int32+++fileInfoGetAttributeInt32 ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    m Int32+fileInfoGetAttributeInt32 _obj attribute = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    result <- g_file_info_get_attribute_int32 _obj' attribute'+    touchManagedPtr _obj+    freeMem attribute'+    return result++-- method FileInfo::get_attribute_int64+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_get_attribute_int64" g_file_info_get_attribute_int64 :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CString ->                              -- attribute : TBasicType TUTF8+    IO Int64+++fileInfoGetAttributeInt64 ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    m Int64+fileInfoGetAttributeInt64 _obj attribute = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    result <- g_file_info_get_attribute_int64 _obj' attribute'+    touchManagedPtr _obj+    freeMem attribute'+    return result++-- method FileInfo::get_attribute_object+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GObject" "Object"+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_get_attribute_object" g_file_info_get_attribute_object :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CString ->                              -- attribute : TBasicType TUTF8+    IO (Ptr GObject.Object)+++fileInfoGetAttributeObject ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    m GObject.Object+fileInfoGetAttributeObject _obj attribute = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    result <- g_file_info_get_attribute_object _obj' attribute'+    checkUnexpectedReturnNULL "g_file_info_get_attribute_object" result+    result' <- (newObject GObject.Object) result+    touchManagedPtr _obj+    freeMem attribute'+    return result'++-- method FileInfo::get_attribute_status+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileAttributeStatus"+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_get_attribute_status" g_file_info_get_attribute_status :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CString ->                              -- attribute : TBasicType TUTF8+    IO CUInt+++fileInfoGetAttributeStatus ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    m FileAttributeStatus+fileInfoGetAttributeStatus _obj attribute = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    result <- g_file_info_get_attribute_status _obj' attribute'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    freeMem attribute'+    return result'++-- method FileInfo::get_attribute_string+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_get_attribute_string" g_file_info_get_attribute_string :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CString ->                              -- attribute : TBasicType TUTF8+    IO CString+++fileInfoGetAttributeString ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    m T.Text+fileInfoGetAttributeString _obj attribute = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    result <- g_file_info_get_attribute_string _obj' attribute'+    checkUnexpectedReturnNULL "g_file_info_get_attribute_string" result+    result' <- cstringToText result+    touchManagedPtr _obj+    freeMem attribute'+    return result'++-- method FileInfo::get_attribute_stringv+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_get_attribute_stringv" g_file_info_get_attribute_stringv :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CString ->                              -- attribute : TBasicType TUTF8+    IO (Ptr CString)+++fileInfoGetAttributeStringv ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    m [T.Text]+fileInfoGetAttributeStringv _obj attribute = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    result <- g_file_info_get_attribute_stringv _obj' attribute'+    checkUnexpectedReturnNULL "g_file_info_get_attribute_stringv" result+    result' <- unpackZeroTerminatedUTF8CArray result+    touchManagedPtr _obj+    freeMem attribute'+    return result'++-- method FileInfo::get_attribute_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileAttributeType"+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_get_attribute_type" g_file_info_get_attribute_type :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CString ->                              -- attribute : TBasicType TUTF8+    IO CUInt+++fileInfoGetAttributeType ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    m FileAttributeType+fileInfoGetAttributeType _obj attribute = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    result <- g_file_info_get_attribute_type _obj' attribute'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    freeMem attribute'+    return result'++-- method FileInfo::get_attribute_uint32+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_get_attribute_uint32" g_file_info_get_attribute_uint32 :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CString ->                              -- attribute : TBasicType TUTF8+    IO Word32+++fileInfoGetAttributeUint32 ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    m Word32+fileInfoGetAttributeUint32 _obj attribute = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    result <- g_file_info_get_attribute_uint32 _obj' attribute'+    touchManagedPtr _obj+    freeMem attribute'+    return result++-- method FileInfo::get_attribute_uint64+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_get_attribute_uint64" g_file_info_get_attribute_uint64 :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CString ->                              -- attribute : TBasicType TUTF8+    IO Word64+++fileInfoGetAttributeUint64 ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    m Word64+fileInfoGetAttributeUint64 _obj attribute = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    result <- g_file_info_get_attribute_uint64 _obj' attribute'+    touchManagedPtr _obj+    freeMem attribute'+    return result++-- method FileInfo::get_content_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_get_content_type" g_file_info_get_content_type :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    IO CString+++fileInfoGetContentType ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    m T.Text+fileInfoGetContentType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_info_get_content_type _obj'+    checkUnexpectedReturnNULL "g_file_info_get_content_type" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method FileInfo::get_deletion_date+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GLib" "DateTime"+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_get_deletion_date" g_file_info_get_deletion_date :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    IO (Ptr GLib.DateTime)+++fileInfoGetDeletionDate ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    m GLib.DateTime+fileInfoGetDeletionDate _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_info_get_deletion_date _obj'+    checkUnexpectedReturnNULL "g_file_info_get_deletion_date" result+    result' <- (wrapBoxed GLib.DateTime) result+    touchManagedPtr _obj+    return result'++-- method FileInfo::get_display_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_get_display_name" g_file_info_get_display_name :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    IO CString+++fileInfoGetDisplayName ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    m T.Text+fileInfoGetDisplayName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_info_get_display_name _obj'+    checkUnexpectedReturnNULL "g_file_info_get_display_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method FileInfo::get_edit_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_get_edit_name" g_file_info_get_edit_name :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    IO CString+++fileInfoGetEditName ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    m T.Text+fileInfoGetEditName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_info_get_edit_name _obj'+    checkUnexpectedReturnNULL "g_file_info_get_edit_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method FileInfo::get_etag+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_get_etag" g_file_info_get_etag :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    IO CString+++fileInfoGetEtag ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    m T.Text+fileInfoGetEtag _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_info_get_etag _obj'+    checkUnexpectedReturnNULL "g_file_info_get_etag" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method FileInfo::get_file_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileType"+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_get_file_type" g_file_info_get_file_type :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    IO CUInt+++fileInfoGetFileType ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    m FileType+fileInfoGetFileType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_info_get_file_type _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method FileInfo::get_icon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Icon"+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_get_icon" g_file_info_get_icon :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    IO (Ptr Icon)+++fileInfoGetIcon ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    m Icon+fileInfoGetIcon _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_info_get_icon _obj'+    checkUnexpectedReturnNULL "g_file_info_get_icon" result+    result' <- (newObject Icon) result+    touchManagedPtr _obj+    return result'++-- method FileInfo::get_is_backup+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_get_is_backup" g_file_info_get_is_backup :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    IO CInt+++fileInfoGetIsBackup ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    m Bool+fileInfoGetIsBackup _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_info_get_is_backup _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FileInfo::get_is_hidden+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_get_is_hidden" g_file_info_get_is_hidden :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    IO CInt+++fileInfoGetIsHidden ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    m Bool+fileInfoGetIsHidden _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_info_get_is_hidden _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FileInfo::get_is_symlink+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_get_is_symlink" g_file_info_get_is_symlink :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    IO CInt+++fileInfoGetIsSymlink ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    m Bool+fileInfoGetIsSymlink _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_info_get_is_symlink _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FileInfo::get_modification_time+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "GLib" "TimeVal", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_get_modification_time" g_file_info_get_modification_time :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    Ptr GLib.TimeVal ->                     -- result : TInterface "GLib" "TimeVal"+    IO ()+++fileInfoGetModificationTime ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    m (GLib.TimeVal)+fileInfoGetModificationTime _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result_ <- callocBytes 16 :: IO (Ptr GLib.TimeVal)+    g_file_info_get_modification_time _obj' result_+    result_' <- (wrapPtr GLib.TimeVal) result_+    touchManagedPtr _obj+    return result_'++-- method FileInfo::get_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_get_name" g_file_info_get_name :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    IO CString+++fileInfoGetName ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    m T.Text+fileInfoGetName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_info_get_name _obj'+    checkUnexpectedReturnNULL "g_file_info_get_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method FileInfo::get_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_get_size" g_file_info_get_size :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    IO Int64+++fileInfoGetSize ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    m Int64+fileInfoGetSize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_info_get_size _obj'+    touchManagedPtr _obj+    return result++-- method FileInfo::get_sort_order+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_get_sort_order" g_file_info_get_sort_order :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    IO Int32+++fileInfoGetSortOrder ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    m Int32+fileInfoGetSortOrder _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_info_get_sort_order _obj'+    touchManagedPtr _obj+    return result++-- method FileInfo::get_symbolic_icon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Icon"+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_get_symbolic_icon" g_file_info_get_symbolic_icon :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    IO (Ptr Icon)+++fileInfoGetSymbolicIcon ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    m Icon+fileInfoGetSymbolicIcon _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_info_get_symbolic_icon _obj'+    checkUnexpectedReturnNULL "g_file_info_get_symbolic_icon" result+    result' <- (newObject Icon) result+    touchManagedPtr _obj+    return result'++-- method FileInfo::get_symlink_target+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_get_symlink_target" g_file_info_get_symlink_target :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    IO CString+++fileInfoGetSymlinkTarget ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    m T.Text+fileInfoGetSymlinkTarget _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_info_get_symlink_target _obj'+    checkUnexpectedReturnNULL "g_file_info_get_symlink_target" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method FileInfo::has_attribute+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_has_attribute" g_file_info_has_attribute :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CString ->                              -- attribute : TBasicType TUTF8+    IO CInt+++fileInfoHasAttribute ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    m Bool+fileInfoHasAttribute _obj attribute = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    result <- g_file_info_has_attribute _obj' attribute'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem attribute'+    return result'++-- method FileInfo::has_namespace+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name_space", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name_space", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_has_namespace" g_file_info_has_namespace :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CString ->                              -- name_space : TBasicType TUTF8+    IO CInt+++fileInfoHasNamespace ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- name_space+    m Bool+fileInfoHasNamespace _obj name_space = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name_space' <- textToCString name_space+    result <- g_file_info_has_namespace _obj' name_space'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem name_space'+    return result'++-- method FileInfo::list_attributes+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name_space", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name_space", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_list_attributes" g_file_info_list_attributes :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CString ->                              -- name_space : TBasicType TUTF8+    IO (Ptr CString)+++fileInfoListAttributes ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- name_space+    m [T.Text]+fileInfoListAttributes _obj name_space = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name_space' <- textToCString name_space+    result <- g_file_info_list_attributes _obj' name_space'+    checkUnexpectedReturnNULL "g_file_info_list_attributes" result+    result' <- unpackZeroTerminatedUTF8CArray result+    mapZeroTerminatedCArray freeMem result+    freeMem result+    touchManagedPtr _obj+    freeMem name_space'+    return result'++-- method FileInfo::remove_attribute+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_remove_attribute" g_file_info_remove_attribute :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CString ->                              -- attribute : TBasicType TUTF8+    IO ()+++fileInfoRemoveAttribute ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    m ()+fileInfoRemoveAttribute _obj attribute = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    g_file_info_remove_attribute _obj' attribute'+    touchManagedPtr _obj+    freeMem attribute'+    return ()++-- method FileInfo::set_attribute+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "Gio" "FileAttributeType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value_p", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "Gio" "FileAttributeType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value_p", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_set_attribute" g_file_info_set_attribute :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CString ->                              -- attribute : TBasicType TUTF8+    CUInt ->                                -- type : TInterface "Gio" "FileAttributeType"+    Ptr () ->                               -- value_p : TBasicType TVoid+    IO ()+++fileInfoSetAttribute ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    FileAttributeType ->                    -- type+    Ptr () ->                               -- value_p+    m ()+fileInfoSetAttribute _obj attribute type_ value_p = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    let type_' = (fromIntegral . fromEnum) type_+    g_file_info_set_attribute _obj' attribute' type_' value_p+    touchManagedPtr _obj+    freeMem attribute'+    return ()++-- method FileInfo::set_attribute_boolean+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attr_value", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attr_value", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_set_attribute_boolean" g_file_info_set_attribute_boolean :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CString ->                              -- attribute : TBasicType TUTF8+    CInt ->                                 -- attr_value : TBasicType TBoolean+    IO ()+++fileInfoSetAttributeBoolean ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    Bool ->                                 -- attr_value+    m ()+fileInfoSetAttributeBoolean _obj attribute attr_value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    let attr_value' = (fromIntegral . fromEnum) attr_value+    g_file_info_set_attribute_boolean _obj' attribute' attr_value'+    touchManagedPtr _obj+    freeMem attribute'+    return ()++-- method FileInfo::set_attribute_byte_string+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attr_value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attr_value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_set_attribute_byte_string" g_file_info_set_attribute_byte_string :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CString ->                              -- attribute : TBasicType TUTF8+    CString ->                              -- attr_value : TBasicType TUTF8+    IO ()+++fileInfoSetAttributeByteString ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    T.Text ->                               -- attr_value+    m ()+fileInfoSetAttributeByteString _obj attribute attr_value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    attr_value' <- textToCString attr_value+    g_file_info_set_attribute_byte_string _obj' attribute' attr_value'+    touchManagedPtr _obj+    freeMem attribute'+    freeMem attr_value'+    return ()++-- method FileInfo::set_attribute_int32+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attr_value", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attr_value", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_set_attribute_int32" g_file_info_set_attribute_int32 :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CString ->                              -- attribute : TBasicType TUTF8+    Int32 ->                                -- attr_value : TBasicType TInt32+    IO ()+++fileInfoSetAttributeInt32 ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    Int32 ->                                -- attr_value+    m ()+fileInfoSetAttributeInt32 _obj attribute attr_value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    g_file_info_set_attribute_int32 _obj' attribute' attr_value+    touchManagedPtr _obj+    freeMem attribute'+    return ()++-- method FileInfo::set_attribute_int64+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attr_value", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attr_value", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_set_attribute_int64" g_file_info_set_attribute_int64 :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CString ->                              -- attribute : TBasicType TUTF8+    Int64 ->                                -- attr_value : TBasicType TInt64+    IO ()+++fileInfoSetAttributeInt64 ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    Int64 ->                                -- attr_value+    m ()+fileInfoSetAttributeInt64 _obj attribute attr_value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    g_file_info_set_attribute_int64 _obj' attribute' attr_value+    touchManagedPtr _obj+    freeMem attribute'+    return ()++-- method FileInfo::set_attribute_mask+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mask", argType = TInterface "Gio" "FileAttributeMatcher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mask", argType = TInterface "Gio" "FileAttributeMatcher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_set_attribute_mask" g_file_info_set_attribute_mask :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    Ptr FileAttributeMatcher ->             -- mask : TInterface "Gio" "FileAttributeMatcher"+    IO ()+++fileInfoSetAttributeMask ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    FileAttributeMatcher ->                 -- mask+    m ()+fileInfoSetAttributeMask _obj mask = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let mask' = unsafeManagedPtrGetPtr mask+    g_file_info_set_attribute_mask _obj' mask'+    touchManagedPtr _obj+    touchManagedPtr mask+    return ()++-- method FileInfo::set_attribute_object+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attr_value", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attr_value", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_set_attribute_object" g_file_info_set_attribute_object :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CString ->                              -- attribute : TBasicType TUTF8+    Ptr GObject.Object ->                   -- attr_value : TInterface "GObject" "Object"+    IO ()+++fileInfoSetAttributeObject ::+    (MonadIO m, FileInfoK a, GObject.ObjectK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    b ->                                    -- attr_value+    m ()+fileInfoSetAttributeObject _obj attribute attr_value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    let attr_value' = unsafeManagedPtrCastPtr attr_value+    g_file_info_set_attribute_object _obj' attribute' attr_value'+    touchManagedPtr _obj+    touchManagedPtr attr_value+    freeMem attribute'+    return ()++-- method FileInfo::set_attribute_status+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "status", argType = TInterface "Gio" "FileAttributeStatus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "status", argType = TInterface "Gio" "FileAttributeStatus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_set_attribute_status" g_file_info_set_attribute_status :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CString ->                              -- attribute : TBasicType TUTF8+    CUInt ->                                -- status : TInterface "Gio" "FileAttributeStatus"+    IO CInt+++fileInfoSetAttributeStatus ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    FileAttributeStatus ->                  -- status+    m Bool+fileInfoSetAttributeStatus _obj attribute status = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    let status' = (fromIntegral . fromEnum) status+    result <- g_file_info_set_attribute_status _obj' attribute' status'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem attribute'+    return result'++-- method FileInfo::set_attribute_string+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attr_value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attr_value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_set_attribute_string" g_file_info_set_attribute_string :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CString ->                              -- attribute : TBasicType TUTF8+    CString ->                              -- attr_value : TBasicType TUTF8+    IO ()+++fileInfoSetAttributeString ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    T.Text ->                               -- attr_value+    m ()+fileInfoSetAttributeString _obj attribute attr_value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    attr_value' <- textToCString attr_value+    g_file_info_set_attribute_string _obj' attribute' attr_value'+    touchManagedPtr _obj+    freeMem attribute'+    freeMem attr_value'+    return ()++-- method FileInfo::set_attribute_stringv+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attr_value", argType = TCArray False (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attr_value", argType = TCArray False (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_set_attribute_stringv" g_file_info_set_attribute_stringv :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CString ->                              -- attribute : TBasicType TUTF8+    Ptr CString ->                          -- attr_value : TCArray False (-1) (-1) (TBasicType TUTF8)+    IO ()+++fileInfoSetAttributeStringv ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    Ptr CString ->                          -- attr_value+    m ()+fileInfoSetAttributeStringv _obj attribute attr_value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    g_file_info_set_attribute_stringv _obj' attribute' attr_value+    touchManagedPtr _obj+    freeMem attribute'+    return ()++-- method FileInfo::set_attribute_uint32+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attr_value", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attr_value", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_set_attribute_uint32" g_file_info_set_attribute_uint32 :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CString ->                              -- attribute : TBasicType TUTF8+    Word32 ->                               -- attr_value : TBasicType TUInt32+    IO ()+++fileInfoSetAttributeUint32 ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    Word32 ->                               -- attr_value+    m ()+fileInfoSetAttributeUint32 _obj attribute attr_value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    g_file_info_set_attribute_uint32 _obj' attribute' attr_value+    touchManagedPtr _obj+    freeMem attribute'+    return ()++-- method FileInfo::set_attribute_uint64+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attr_value", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attr_value", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_set_attribute_uint64" g_file_info_set_attribute_uint64 :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CString ->                              -- attribute : TBasicType TUTF8+    Word64 ->                               -- attr_value : TBasicType TUInt64+    IO ()+++fileInfoSetAttributeUint64 ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    Word64 ->                               -- attr_value+    m ()+fileInfoSetAttributeUint64 _obj attribute attr_value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    g_file_info_set_attribute_uint64 _obj' attribute' attr_value+    touchManagedPtr _obj+    freeMem attribute'+    return ()++-- method FileInfo::set_content_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "content_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "content_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_set_content_type" g_file_info_set_content_type :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CString ->                              -- content_type : TBasicType TUTF8+    IO ()+++fileInfoSetContentType ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- content_type+    m ()+fileInfoSetContentType _obj content_type = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    content_type' <- textToCString content_type+    g_file_info_set_content_type _obj' content_type'+    touchManagedPtr _obj+    freeMem content_type'+    return ()++-- method FileInfo::set_display_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "display_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "display_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_set_display_name" g_file_info_set_display_name :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CString ->                              -- display_name : TBasicType TUTF8+    IO ()+++fileInfoSetDisplayName ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- display_name+    m ()+fileInfoSetDisplayName _obj display_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    display_name' <- textToCString display_name+    g_file_info_set_display_name _obj' display_name'+    touchManagedPtr _obj+    freeMem display_name'+    return ()++-- method FileInfo::set_edit_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "edit_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "edit_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_set_edit_name" g_file_info_set_edit_name :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CString ->                              -- edit_name : TBasicType TUTF8+    IO ()+++fileInfoSetEditName ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- edit_name+    m ()+fileInfoSetEditName _obj edit_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    edit_name' <- textToCString edit_name+    g_file_info_set_edit_name _obj' edit_name'+    touchManagedPtr _obj+    freeMem edit_name'+    return ()++-- method FileInfo::set_file_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "Gio" "FileType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "Gio" "FileType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_set_file_type" g_file_info_set_file_type :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CUInt ->                                -- type : TInterface "Gio" "FileType"+    IO ()+++fileInfoSetFileType ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    FileType ->                             -- type+    m ()+fileInfoSetFileType _obj type_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let type_' = (fromIntegral . fromEnum) type_+    g_file_info_set_file_type _obj' type_'+    touchManagedPtr _obj+    return ()++-- method FileInfo::set_icon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon", argType = TInterface "Gio" "Icon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon", argType = TInterface "Gio" "Icon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_set_icon" g_file_info_set_icon :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    Ptr Icon ->                             -- icon : TInterface "Gio" "Icon"+    IO ()+++fileInfoSetIcon ::+    (MonadIO m, FileInfoK a, IconK b) =>+    a ->                                    -- _obj+    b ->                                    -- icon+    m ()+fileInfoSetIcon _obj icon = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let icon' = unsafeManagedPtrCastPtr icon+    g_file_info_set_icon _obj' icon'+    touchManagedPtr _obj+    touchManagedPtr icon+    return ()++-- method FileInfo::set_is_hidden+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "is_hidden", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "is_hidden", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_set_is_hidden" g_file_info_set_is_hidden :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CInt ->                                 -- is_hidden : TBasicType TBoolean+    IO ()+++fileInfoSetIsHidden ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- is_hidden+    m ()+fileInfoSetIsHidden _obj is_hidden = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let is_hidden' = (fromIntegral . fromEnum) is_hidden+    g_file_info_set_is_hidden _obj' is_hidden'+    touchManagedPtr _obj+    return ()++-- method FileInfo::set_is_symlink+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "is_symlink", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "is_symlink", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_set_is_symlink" g_file_info_set_is_symlink :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CInt ->                                 -- is_symlink : TBasicType TBoolean+    IO ()+++fileInfoSetIsSymlink ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- is_symlink+    m ()+fileInfoSetIsSymlink _obj is_symlink = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let is_symlink' = (fromIntegral . fromEnum) is_symlink+    g_file_info_set_is_symlink _obj' is_symlink'+    touchManagedPtr _obj+    return ()++-- method FileInfo::set_modification_time+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mtime", argType = TInterface "GLib" "TimeVal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mtime", argType = TInterface "GLib" "TimeVal", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_set_modification_time" g_file_info_set_modification_time :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    Ptr GLib.TimeVal ->                     -- mtime : TInterface "GLib" "TimeVal"+    IO ()+++fileInfoSetModificationTime ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    GLib.TimeVal ->                         -- mtime+    m ()+fileInfoSetModificationTime _obj mtime = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let mtime' = unsafeManagedPtrGetPtr mtime+    g_file_info_set_modification_time _obj' mtime'+    touchManagedPtr _obj+    touchManagedPtr mtime+    return ()++-- method FileInfo::set_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_set_name" g_file_info_set_name :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CString ->                              -- name : TBasicType TUTF8+    IO ()+++fileInfoSetName ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- name+    m ()+fileInfoSetName _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name' <- textToCString name+    g_file_info_set_name _obj' name'+    touchManagedPtr _obj+    freeMem name'+    return ()++-- method FileInfo::set_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_set_size" g_file_info_set_size :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    Int64 ->                                -- size : TBasicType TInt64+    IO ()+++fileInfoSetSize ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    Int64 ->                                -- size+    m ()+fileInfoSetSize _obj size = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_file_info_set_size _obj' size+    touchManagedPtr _obj+    return ()++-- method FileInfo::set_sort_order+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sort_order", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sort_order", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_set_sort_order" g_file_info_set_sort_order :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    Int32 ->                                -- sort_order : TBasicType TInt32+    IO ()+++fileInfoSetSortOrder ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- sort_order+    m ()+fileInfoSetSortOrder _obj sort_order = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_file_info_set_sort_order _obj' sort_order+    touchManagedPtr _obj+    return ()++-- method FileInfo::set_symbolic_icon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon", argType = TInterface "Gio" "Icon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon", argType = TInterface "Gio" "Icon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_set_symbolic_icon" g_file_info_set_symbolic_icon :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    Ptr Icon ->                             -- icon : TInterface "Gio" "Icon"+    IO ()+++fileInfoSetSymbolicIcon ::+    (MonadIO m, FileInfoK a, IconK b) =>+    a ->                                    -- _obj+    b ->                                    -- icon+    m ()+fileInfoSetSymbolicIcon _obj icon = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let icon' = unsafeManagedPtrCastPtr icon+    g_file_info_set_symbolic_icon _obj' icon'+    touchManagedPtr _obj+    touchManagedPtr icon+    return ()++-- method FileInfo::set_symlink_target+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "symlink_target", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "symlink_target", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_set_symlink_target" g_file_info_set_symlink_target :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    CString ->                              -- symlink_target : TBasicType TUTF8+    IO ()+++fileInfoSetSymlinkTarget ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- symlink_target+    m ()+fileInfoSetSymlinkTarget _obj symlink_target = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    symlink_target' <- textToCString symlink_target+    g_file_info_set_symlink_target _obj' symlink_target'+    touchManagedPtr _obj+    freeMem symlink_target'+    return ()++-- method FileInfo::unset_attribute_mask+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_info_unset_attribute_mask" g_file_info_unset_attribute_mask :: +    Ptr FileInfo ->                         -- _obj : TInterface "Gio" "FileInfo"+    IO ()+++fileInfoUnsetAttributeMask ::+    (MonadIO m, FileInfoK a) =>+    a ->                                    -- _obj+    m ()+fileInfoUnsetAttributeMask _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_file_info_unset_attribute_mask _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Objects/FileInfo.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Objects.FileInfo where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype FileInfo = FileInfo (ForeignPtr FileInfo)+instance GObject FileInfo where+class GObject o => FileInfoK o+instance (GObject o, IsDescendantOf FileInfo o) => FileInfoK o
+ GI/Gio/Objects/FileInputStream.hs view
@@ -0,0 +1,200 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.FileInputStream+    ( ++-- * Exported types+    FileInputStream(..)                     ,+    FileInputStreamK                        ,+    toFileInputStream                       ,+    noFileInputStream                       ,+++ -- * Methods+-- ** fileInputStreamQueryInfo+    fileInputStreamQueryInfo                ,+++-- ** fileInputStreamQueryInfoAsync+    fileInputStreamQueryInfoAsync           ,+++-- ** fileInputStreamQueryInfoFinish+    fileInputStreamQueryInfoFinish          ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype FileInputStream = FileInputStream (ForeignPtr FileInputStream)+foreign import ccall "g_file_input_stream_get_type"+    c_g_file_input_stream_get_type :: IO GType++type instance ParentTypes FileInputStream = FileInputStreamParentTypes+type FileInputStreamParentTypes = '[InputStream, GObject.Object, Seekable]++instance GObject FileInputStream where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_file_input_stream_get_type+    ++class GObject o => FileInputStreamK o+instance (GObject o, IsDescendantOf FileInputStream o) => FileInputStreamK o++toFileInputStream :: FileInputStreamK o => o -> IO FileInputStream+toFileInputStream = unsafeCastTo FileInputStream++noFileInputStream :: Maybe FileInputStream+noFileInputStream = Nothing++type instance AttributeList FileInputStream = FileInputStreamAttributeList+type FileInputStreamAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList FileInputStream = FileInputStreamSignalList+type FileInputStreamSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method FileInputStream::query_info+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attributes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attributes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileInfo"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_input_stream_query_info" g_file_input_stream_query_info :: +    Ptr FileInputStream ->                  -- _obj : TInterface "Gio" "FileInputStream"+    CString ->                              -- attributes : TBasicType TUTF8+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr FileInfo)+++fileInputStreamQueryInfo ::+    (MonadIO m, FileInputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- attributes+    Maybe (b) ->                            -- cancellable+    m FileInfo+fileInputStreamQueryInfo _obj attributes cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attributes' <- textToCString attributes+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_file_input_stream_query_info _obj' attributes' maybeCancellable+        checkUnexpectedReturnNULL "g_file_input_stream_query_info" result+        result' <- (wrapObject FileInfo) result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem attributes'+        return result'+     ) (do+        freeMem attributes'+     )++-- method FileInputStream::query_info_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attributes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attributes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_input_stream_query_info_async" g_file_input_stream_query_info_async :: +    Ptr FileInputStream ->                  -- _obj : TInterface "Gio" "FileInputStream"+    CString ->                              -- attributes : TBasicType TUTF8+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++fileInputStreamQueryInfoAsync ::+    (MonadIO m, FileInputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- attributes+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+fileInputStreamQueryInfoAsync _obj attributes io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attributes' <- textToCString attributes+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_file_input_stream_query_info_async _obj' attributes' io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    freeMem attributes'+    return ()++-- method FileInputStream::query_info_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileInfo"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_input_stream_query_info_finish" g_file_input_stream_query_info_finish :: +    Ptr FileInputStream ->                  -- _obj : TInterface "Gio" "FileInputStream"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr FileInfo)+++fileInputStreamQueryInfoFinish ::+    (MonadIO m, FileInputStreamK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m FileInfo+fileInputStreamQueryInfoFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        result <- propagateGError $ g_file_input_stream_query_info_finish _obj' result_'+        checkUnexpectedReturnNULL "g_file_input_stream_query_info_finish" result+        result' <- (wrapObject FileInfo) result+        touchManagedPtr _obj+        touchManagedPtr result_+        return result'+     ) (do+        return ()+     )++
+ GI/Gio/Objects/FileInputStream.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Objects.FileInputStream where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype FileInputStream = FileInputStream (ForeignPtr FileInputStream)+instance GObject FileInputStream where+class GObject o => FileInputStreamK o+instance (GObject o, IsDescendantOf FileInputStream o) => FileInputStreamK o
+ GI/Gio/Objects/FileMonitor.hs view
@@ -0,0 +1,320 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.FileMonitor+    ( ++-- * Exported types+    FileMonitor(..)                         ,+    FileMonitorK                            ,+    toFileMonitor                           ,+    noFileMonitor                           ,+++ -- * Methods+-- ** fileMonitorCancel+    fileMonitorCancel                       ,+++-- ** fileMonitorEmitEvent+    fileMonitorEmitEvent                    ,+++-- ** fileMonitorIsCancelled+    fileMonitorIsCancelled                  ,+++-- ** fileMonitorSetRateLimit+    fileMonitorSetRateLimit                 ,+++++ -- * Properties+-- ** Cancelled+    FileMonitorCancelledPropertyInfo        ,+    getFileMonitorCancelled                 ,+++-- ** RateLimit+    FileMonitorRateLimitPropertyInfo        ,+    constructFileMonitorRateLimit           ,+    getFileMonitorRateLimit                 ,+    setFileMonitorRateLimit                 ,+++++ -- * Signals+-- ** Changed+    FileMonitorChangedCallback              ,+    FileMonitorChangedCallbackC             ,+    FileMonitorChangedSignalInfo            ,+    afterFileMonitorChanged                 ,+    fileMonitorChangedCallbackWrapper       ,+    fileMonitorChangedClosure               ,+    mkFileMonitorChangedCallback            ,+    noFileMonitorChangedCallback            ,+    onFileMonitorChanged                    ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype FileMonitor = FileMonitor (ForeignPtr FileMonitor)+foreign import ccall "g_file_monitor_get_type"+    c_g_file_monitor_get_type :: IO GType++type instance ParentTypes FileMonitor = FileMonitorParentTypes+type FileMonitorParentTypes = '[GObject.Object]++instance GObject FileMonitor where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_file_monitor_get_type+    ++class GObject o => FileMonitorK o+instance (GObject o, IsDescendantOf FileMonitor o) => FileMonitorK o++toFileMonitor :: FileMonitorK o => o -> IO FileMonitor+toFileMonitor = unsafeCastTo FileMonitor++noFileMonitor :: Maybe FileMonitor+noFileMonitor = Nothing++-- signal FileMonitor::changed+type FileMonitorChangedCallback =+    File ->+    Maybe File ->+    FileMonitorEvent ->+    IO ()++noFileMonitorChangedCallback :: Maybe FileMonitorChangedCallback+noFileMonitorChangedCallback = Nothing++type FileMonitorChangedCallbackC =+    Ptr () ->                               -- object+    Ptr File ->+    Ptr File ->+    CUInt ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkFileMonitorChangedCallback :: FileMonitorChangedCallbackC -> IO (FunPtr FileMonitorChangedCallbackC)++fileMonitorChangedClosure :: FileMonitorChangedCallback -> IO Closure+fileMonitorChangedClosure cb = newCClosure =<< mkFileMonitorChangedCallback wrapped+    where wrapped = fileMonitorChangedCallbackWrapper cb++fileMonitorChangedCallbackWrapper ::+    FileMonitorChangedCallback ->+    Ptr () ->+    Ptr File ->+    Ptr File ->+    CUInt ->+    Ptr () ->+    IO ()+fileMonitorChangedCallbackWrapper _cb _ file other_file event_type _ = do+    file' <- (newObject File) file+    maybeOther_file <-+        if other_file == nullPtr+        then return Nothing+        else do+            other_file' <- (newObject File) other_file+            return $ Just other_file'+    let event_type' = (toEnum . fromIntegral) event_type+    _cb  file' maybeOther_file event_type'++onFileMonitorChanged :: (GObject a, MonadIO m) => a -> FileMonitorChangedCallback -> m SignalHandlerId+onFileMonitorChanged obj cb = liftIO $ connectFileMonitorChanged obj cb SignalConnectBefore+afterFileMonitorChanged :: (GObject a, MonadIO m) => a -> FileMonitorChangedCallback -> m SignalHandlerId+afterFileMonitorChanged obj cb = connectFileMonitorChanged obj cb SignalConnectAfter++connectFileMonitorChanged :: (GObject a, MonadIO m) =>+                             a -> FileMonitorChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectFileMonitorChanged obj cb after = liftIO $ do+    cb' <- mkFileMonitorChangedCallback (fileMonitorChangedCallbackWrapper cb)+    connectSignalFunPtr obj "changed" cb' after++-- VVV Prop "cancelled"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getFileMonitorCancelled :: (MonadIO m, FileMonitorK o) => o -> m Bool+getFileMonitorCancelled obj = liftIO $ getObjectPropertyBool obj "cancelled"++data FileMonitorCancelledPropertyInfo+instance AttrInfo FileMonitorCancelledPropertyInfo where+    type AttrAllowedOps FileMonitorCancelledPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint FileMonitorCancelledPropertyInfo = (~) ()+    type AttrBaseTypeConstraint FileMonitorCancelledPropertyInfo = FileMonitorK+    type AttrGetType FileMonitorCancelledPropertyInfo = Bool+    type AttrLabel FileMonitorCancelledPropertyInfo = "FileMonitor::cancelled"+    attrGet _ = getFileMonitorCancelled+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "rate-limit"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getFileMonitorRateLimit :: (MonadIO m, FileMonitorK o) => o -> m Int32+getFileMonitorRateLimit obj = liftIO $ getObjectPropertyCInt obj "rate-limit"++setFileMonitorRateLimit :: (MonadIO m, FileMonitorK o) => o -> Int32 -> m ()+setFileMonitorRateLimit obj val = liftIO $ setObjectPropertyCInt obj "rate-limit" val++constructFileMonitorRateLimit :: Int32 -> IO ([Char], GValue)+constructFileMonitorRateLimit val = constructObjectPropertyCInt "rate-limit" val++data FileMonitorRateLimitPropertyInfo+instance AttrInfo FileMonitorRateLimitPropertyInfo where+    type AttrAllowedOps FileMonitorRateLimitPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FileMonitorRateLimitPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint FileMonitorRateLimitPropertyInfo = FileMonitorK+    type AttrGetType FileMonitorRateLimitPropertyInfo = Int32+    type AttrLabel FileMonitorRateLimitPropertyInfo = "FileMonitor::rate-limit"+    attrGet _ = getFileMonitorRateLimit+    attrSet _ = setFileMonitorRateLimit+    attrConstruct _ = constructFileMonitorRateLimit++type instance AttributeList FileMonitor = FileMonitorAttributeList+type FileMonitorAttributeList = ('[ '("cancelled", FileMonitorCancelledPropertyInfo), '("rate-limit", FileMonitorRateLimitPropertyInfo)] :: [(Symbol, *)])++data FileMonitorChangedSignalInfo+instance SignalInfo FileMonitorChangedSignalInfo where+    type HaskellCallbackType FileMonitorChangedSignalInfo = FileMonitorChangedCallback+    connectSignal _ = connectFileMonitorChanged++type instance SignalList FileMonitor = FileMonitorSignalList+type FileMonitorSignalList = ('[ '("changed", FileMonitorChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method FileMonitor::cancel+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_file_monitor_cancel" g_file_monitor_cancel :: +    Ptr FileMonitor ->                      -- _obj : TInterface "Gio" "FileMonitor"+    IO CInt+++fileMonitorCancel ::+    (MonadIO m, FileMonitorK a) =>+    a ->                                    -- _obj+    m Bool+fileMonitorCancel _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_monitor_cancel _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FileMonitor::emit_event+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "other_file", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "event_type", argType = TInterface "Gio" "FileMonitorEvent", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "other_file", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "event_type", argType = TInterface "Gio" "FileMonitorEvent", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_monitor_emit_event" g_file_monitor_emit_event :: +    Ptr FileMonitor ->                      -- _obj : TInterface "Gio" "FileMonitor"+    Ptr File ->                             -- child : TInterface "Gio" "File"+    Ptr File ->                             -- other_file : TInterface "Gio" "File"+    CUInt ->                                -- event_type : TInterface "Gio" "FileMonitorEvent"+    IO ()+++fileMonitorEmitEvent ::+    (MonadIO m, FileMonitorK a, FileK b, FileK c) =>+    a ->                                    -- _obj+    b ->                                    -- child+    c ->                                    -- other_file+    FileMonitorEvent ->                     -- event_type+    m ()+fileMonitorEmitEvent _obj child other_file event_type = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    let other_file' = unsafeManagedPtrCastPtr other_file+    let event_type' = (fromIntegral . fromEnum) event_type+    g_file_monitor_emit_event _obj' child' other_file' event_type'+    touchManagedPtr _obj+    touchManagedPtr child+    touchManagedPtr other_file+    return ()++-- method FileMonitor::is_cancelled+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_file_monitor_is_cancelled" g_file_monitor_is_cancelled :: +    Ptr FileMonitor ->                      -- _obj : TInterface "Gio" "FileMonitor"+    IO CInt+++fileMonitorIsCancelled ::+    (MonadIO m, FileMonitorK a) =>+    a ->                                    -- _obj+    m Bool+fileMonitorIsCancelled _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_monitor_is_cancelled _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FileMonitor::set_rate_limit+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "limit_msecs", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "limit_msecs", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_monitor_set_rate_limit" g_file_monitor_set_rate_limit :: +    Ptr FileMonitor ->                      -- _obj : TInterface "Gio" "FileMonitor"+    Int32 ->                                -- limit_msecs : TBasicType TInt32+    IO ()+++fileMonitorSetRateLimit ::+    (MonadIO m, FileMonitorK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- limit_msecs+    m ()+fileMonitorSetRateLimit _obj limit_msecs = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_file_monitor_set_rate_limit _obj' limit_msecs+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Objects/FileMonitor.hs-boot view
@@ -0,0 +1,16 @@+module GI.Gio.Objects.FileMonitor where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype FileMonitor = FileMonitor (ForeignPtr FileMonitor)+instance GObject FileMonitor where+class GObject o => FileMonitorK o+instance (GObject o, IsDescendantOf FileMonitor o) => FileMonitorK o+data FileMonitorCancelledPropertyInfo+data FileMonitorRateLimitPropertyInfo+data FileMonitorChangedSignalInfo
+ GI/Gio/Objects/FileOutputStream.hs view
@@ -0,0 +1,231 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.FileOutputStream+    ( ++-- * Exported types+    FileOutputStream(..)                    ,+    FileOutputStreamK                       ,+    toFileOutputStream                      ,+    noFileOutputStream                      ,+++ -- * Methods+-- ** fileOutputStreamGetEtag+    fileOutputStreamGetEtag                 ,+++-- ** fileOutputStreamQueryInfo+    fileOutputStreamQueryInfo               ,+++-- ** fileOutputStreamQueryInfoAsync+    fileOutputStreamQueryInfoAsync          ,+++-- ** fileOutputStreamQueryInfoFinish+    fileOutputStreamQueryInfoFinish         ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype FileOutputStream = FileOutputStream (ForeignPtr FileOutputStream)+foreign import ccall "g_file_output_stream_get_type"+    c_g_file_output_stream_get_type :: IO GType++type instance ParentTypes FileOutputStream = FileOutputStreamParentTypes+type FileOutputStreamParentTypes = '[OutputStream, GObject.Object, Seekable]++instance GObject FileOutputStream where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_file_output_stream_get_type+    ++class GObject o => FileOutputStreamK o+instance (GObject o, IsDescendantOf FileOutputStream o) => FileOutputStreamK o++toFileOutputStream :: FileOutputStreamK o => o -> IO FileOutputStream+toFileOutputStream = unsafeCastTo FileOutputStream++noFileOutputStream :: Maybe FileOutputStream+noFileOutputStream = Nothing++type instance AttributeList FileOutputStream = FileOutputStreamAttributeList+type FileOutputStreamAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList FileOutputStream = FileOutputStreamSignalList+type FileOutputStreamSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method FileOutputStream::get_etag+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_file_output_stream_get_etag" g_file_output_stream_get_etag :: +    Ptr FileOutputStream ->                 -- _obj : TInterface "Gio" "FileOutputStream"+    IO CString+++fileOutputStreamGetEtag ::+    (MonadIO m, FileOutputStreamK a) =>+    a ->                                    -- _obj+    m T.Text+fileOutputStreamGetEtag _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_file_output_stream_get_etag _obj'+    checkUnexpectedReturnNULL "g_file_output_stream_get_etag" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method FileOutputStream::query_info+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attributes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attributes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileInfo"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_output_stream_query_info" g_file_output_stream_query_info :: +    Ptr FileOutputStream ->                 -- _obj : TInterface "Gio" "FileOutputStream"+    CString ->                              -- attributes : TBasicType TUTF8+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr FileInfo)+++fileOutputStreamQueryInfo ::+    (MonadIO m, FileOutputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- attributes+    Maybe (b) ->                            -- cancellable+    m FileInfo+fileOutputStreamQueryInfo _obj attributes cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attributes' <- textToCString attributes+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_file_output_stream_query_info _obj' attributes' maybeCancellable+        checkUnexpectedReturnNULL "g_file_output_stream_query_info" result+        result' <- (wrapObject FileInfo) result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem attributes'+        return result'+     ) (do+        freeMem attributes'+     )++-- method FileOutputStream::query_info_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attributes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attributes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_output_stream_query_info_async" g_file_output_stream_query_info_async :: +    Ptr FileOutputStream ->                 -- _obj : TInterface "Gio" "FileOutputStream"+    CString ->                              -- attributes : TBasicType TUTF8+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++fileOutputStreamQueryInfoAsync ::+    (MonadIO m, FileOutputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- attributes+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+fileOutputStreamQueryInfoAsync _obj attributes io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attributes' <- textToCString attributes+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_file_output_stream_query_info_async _obj' attributes' io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    freeMem attributes'+    return ()++-- method FileOutputStream::query_info_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileInfo"+-- throws : True+-- Skip return : False++foreign import ccall "g_file_output_stream_query_info_finish" g_file_output_stream_query_info_finish :: +    Ptr FileOutputStream ->                 -- _obj : TInterface "Gio" "FileOutputStream"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr FileInfo)+++fileOutputStreamQueryInfoFinish ::+    (MonadIO m, FileOutputStreamK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m FileInfo+fileOutputStreamQueryInfoFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        result <- propagateGError $ g_file_output_stream_query_info_finish _obj' result_'+        checkUnexpectedReturnNULL "g_file_output_stream_query_info_finish" result+        result' <- (wrapObject FileInfo) result+        touchManagedPtr _obj+        touchManagedPtr result_+        return result'+     ) (do+        return ()+     )++
+ GI/Gio/Objects/FileOutputStream.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Objects.FileOutputStream where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype FileOutputStream = FileOutputStream (ForeignPtr FileOutputStream)+instance GObject FileOutputStream where+class GObject o => FileOutputStreamK o+instance (GObject o, IsDescendantOf FileOutputStream o) => FileOutputStreamK o
+ GI/Gio/Objects/FilenameCompleter.hs view
@@ -0,0 +1,247 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.FilenameCompleter+    ( ++-- * Exported types+    FilenameCompleter(..)                   ,+    FilenameCompleterK                      ,+    toFilenameCompleter                     ,+    noFilenameCompleter                     ,+++ -- * Methods+-- ** filenameCompleterGetCompletionSuffix+    filenameCompleterGetCompletionSuffix    ,+++-- ** filenameCompleterGetCompletions+    filenameCompleterGetCompletions         ,+++-- ** filenameCompleterNew+    filenameCompleterNew                    ,+++-- ** filenameCompleterSetDirsOnly+    filenameCompleterSetDirsOnly            ,+++++ -- * Signals+-- ** GotCompletionData+    FilenameCompleterGotCompletionDataCallback,+    FilenameCompleterGotCompletionDataCallbackC,+    FilenameCompleterGotCompletionDataSignalInfo,+    afterFilenameCompleterGotCompletionData ,+    filenameCompleterGotCompletionDataCallbackWrapper,+    filenameCompleterGotCompletionDataClosure,+    mkFilenameCompleterGotCompletionDataCallback,+    noFilenameCompleterGotCompletionDataCallback,+    onFilenameCompleterGotCompletionData    ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype FilenameCompleter = FilenameCompleter (ForeignPtr FilenameCompleter)+foreign import ccall "g_filename_completer_get_type"+    c_g_filename_completer_get_type :: IO GType++type instance ParentTypes FilenameCompleter = FilenameCompleterParentTypes+type FilenameCompleterParentTypes = '[GObject.Object]++instance GObject FilenameCompleter where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_filename_completer_get_type+    ++class GObject o => FilenameCompleterK o+instance (GObject o, IsDescendantOf FilenameCompleter o) => FilenameCompleterK o++toFilenameCompleter :: FilenameCompleterK o => o -> IO FilenameCompleter+toFilenameCompleter = unsafeCastTo FilenameCompleter++noFilenameCompleter :: Maybe FilenameCompleter+noFilenameCompleter = Nothing++-- signal FilenameCompleter::got-completion-data+type FilenameCompleterGotCompletionDataCallback =+    IO ()++noFilenameCompleterGotCompletionDataCallback :: Maybe FilenameCompleterGotCompletionDataCallback+noFilenameCompleterGotCompletionDataCallback = Nothing++type FilenameCompleterGotCompletionDataCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkFilenameCompleterGotCompletionDataCallback :: FilenameCompleterGotCompletionDataCallbackC -> IO (FunPtr FilenameCompleterGotCompletionDataCallbackC)++filenameCompleterGotCompletionDataClosure :: FilenameCompleterGotCompletionDataCallback -> IO Closure+filenameCompleterGotCompletionDataClosure cb = newCClosure =<< mkFilenameCompleterGotCompletionDataCallback wrapped+    where wrapped = filenameCompleterGotCompletionDataCallbackWrapper cb++filenameCompleterGotCompletionDataCallbackWrapper ::+    FilenameCompleterGotCompletionDataCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+filenameCompleterGotCompletionDataCallbackWrapper _cb _ _ = do+    _cb ++onFilenameCompleterGotCompletionData :: (GObject a, MonadIO m) => a -> FilenameCompleterGotCompletionDataCallback -> m SignalHandlerId+onFilenameCompleterGotCompletionData obj cb = liftIO $ connectFilenameCompleterGotCompletionData obj cb SignalConnectBefore+afterFilenameCompleterGotCompletionData :: (GObject a, MonadIO m) => a -> FilenameCompleterGotCompletionDataCallback -> m SignalHandlerId+afterFilenameCompleterGotCompletionData obj cb = connectFilenameCompleterGotCompletionData obj cb SignalConnectAfter++connectFilenameCompleterGotCompletionData :: (GObject a, MonadIO m) =>+                                             a -> FilenameCompleterGotCompletionDataCallback -> SignalConnectMode -> m SignalHandlerId+connectFilenameCompleterGotCompletionData obj cb after = liftIO $ do+    cb' <- mkFilenameCompleterGotCompletionDataCallback (filenameCompleterGotCompletionDataCallbackWrapper cb)+    connectSignalFunPtr obj "got-completion-data" cb' after++type instance AttributeList FilenameCompleter = FilenameCompleterAttributeList+type FilenameCompleterAttributeList = ('[ ] :: [(Symbol, *)])++data FilenameCompleterGotCompletionDataSignalInfo+instance SignalInfo FilenameCompleterGotCompletionDataSignalInfo where+    type HaskellCallbackType FilenameCompleterGotCompletionDataSignalInfo = FilenameCompleterGotCompletionDataCallback+    connectSignal _ = connectFilenameCompleterGotCompletionData++type instance SignalList FilenameCompleter = FilenameCompleterSignalList+type FilenameCompleterSignalList = ('[ '("got-completion-data", FilenameCompleterGotCompletionDataSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method FilenameCompleter::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gio" "FilenameCompleter"+-- throws : False+-- Skip return : False++foreign import ccall "g_filename_completer_new" g_filename_completer_new :: +    IO (Ptr FilenameCompleter)+++filenameCompleterNew ::+    (MonadIO m) =>+    m FilenameCompleter+filenameCompleterNew  = liftIO $ do+    result <- g_filename_completer_new+    checkUnexpectedReturnNULL "g_filename_completer_new" result+    result' <- (wrapObject FilenameCompleter) result+    return result'++-- method FilenameCompleter::get_completion_suffix+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FilenameCompleter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "initial_text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FilenameCompleter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "initial_text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_filename_completer_get_completion_suffix" g_filename_completer_get_completion_suffix :: +    Ptr FilenameCompleter ->                -- _obj : TInterface "Gio" "FilenameCompleter"+    CString ->                              -- initial_text : TBasicType TUTF8+    IO CString+++filenameCompleterGetCompletionSuffix ::+    (MonadIO m, FilenameCompleterK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- initial_text+    m T.Text+filenameCompleterGetCompletionSuffix _obj initial_text = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    initial_text' <- textToCString initial_text+    result <- g_filename_completer_get_completion_suffix _obj' initial_text'+    checkUnexpectedReturnNULL "g_filename_completer_get_completion_suffix" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    freeMem initial_text'+    return result'++-- method FilenameCompleter::get_completions+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FilenameCompleter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "initial_text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FilenameCompleter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "initial_text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_filename_completer_get_completions" g_filename_completer_get_completions :: +    Ptr FilenameCompleter ->                -- _obj : TInterface "Gio" "FilenameCompleter"+    CString ->                              -- initial_text : TBasicType TUTF8+    IO (Ptr CString)+++filenameCompleterGetCompletions ::+    (MonadIO m, FilenameCompleterK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- initial_text+    m [T.Text]+filenameCompleterGetCompletions _obj initial_text = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    initial_text' <- textToCString initial_text+    result <- g_filename_completer_get_completions _obj' initial_text'+    checkUnexpectedReturnNULL "g_filename_completer_get_completions" result+    result' <- unpackZeroTerminatedUTF8CArray result+    mapZeroTerminatedCArray freeMem result+    freeMem result+    touchManagedPtr _obj+    freeMem initial_text'+    return result'++-- method FilenameCompleter::set_dirs_only+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FilenameCompleter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "dirs_only", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FilenameCompleter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "dirs_only", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_filename_completer_set_dirs_only" g_filename_completer_set_dirs_only :: +    Ptr FilenameCompleter ->                -- _obj : TInterface "Gio" "FilenameCompleter"+    CInt ->                                 -- dirs_only : TBasicType TBoolean+    IO ()+++filenameCompleterSetDirsOnly ::+    (MonadIO m, FilenameCompleterK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- dirs_only+    m ()+filenameCompleterSetDirsOnly _obj dirs_only = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let dirs_only' = (fromIntegral . fromEnum) dirs_only+    g_filename_completer_set_dirs_only _obj' dirs_only'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Objects/FilenameCompleter.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gio.Objects.FilenameCompleter where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype FilenameCompleter = FilenameCompleter (ForeignPtr FilenameCompleter)+instance GObject FilenameCompleter where+class GObject o => FilenameCompleterK o+instance (GObject o, IsDescendantOf FilenameCompleter o) => FilenameCompleterK o+data FilenameCompleterGotCompletionDataSignalInfo
+ GI/Gio/Objects/FilterInputStream.hs view
@@ -0,0 +1,212 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.FilterInputStream+    ( ++-- * Exported types+    FilterInputStream(..)                   ,+    FilterInputStreamK                      ,+    toFilterInputStream                     ,+    noFilterInputStream                     ,+++ -- * Methods+-- ** filterInputStreamGetBaseStream+    filterInputStreamGetBaseStream          ,+++-- ** filterInputStreamGetCloseBaseStream+    filterInputStreamGetCloseBaseStream     ,+++-- ** filterInputStreamSetCloseBaseStream+    filterInputStreamSetCloseBaseStream     ,+++++ -- * Properties+-- ** BaseStream+    FilterInputStreamBaseStreamPropertyInfo ,+    constructFilterInputStreamBaseStream    ,+    getFilterInputStreamBaseStream          ,+++-- ** CloseBaseStream+    FilterInputStreamCloseBaseStreamPropertyInfo,+    constructFilterInputStreamCloseBaseStream,+    getFilterInputStreamCloseBaseStream     ,+    setFilterInputStreamCloseBaseStream     ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype FilterInputStream = FilterInputStream (ForeignPtr FilterInputStream)+foreign import ccall "g_filter_input_stream_get_type"+    c_g_filter_input_stream_get_type :: IO GType++type instance ParentTypes FilterInputStream = FilterInputStreamParentTypes+type FilterInputStreamParentTypes = '[InputStream, GObject.Object]++instance GObject FilterInputStream where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_filter_input_stream_get_type+    ++class GObject o => FilterInputStreamK o+instance (GObject o, IsDescendantOf FilterInputStream o) => FilterInputStreamK o++toFilterInputStream :: FilterInputStreamK o => o -> IO FilterInputStream+toFilterInputStream = unsafeCastTo FilterInputStream++noFilterInputStream :: Maybe FilterInputStream+noFilterInputStream = Nothing++-- VVV Prop "base-stream"+   -- Type: TInterface "Gio" "InputStream"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getFilterInputStreamBaseStream :: (MonadIO m, FilterInputStreamK o) => o -> m InputStream+getFilterInputStreamBaseStream obj = liftIO $ getObjectPropertyObject obj "base-stream" InputStream++constructFilterInputStreamBaseStream :: (InputStreamK a) => a -> IO ([Char], GValue)+constructFilterInputStreamBaseStream val = constructObjectPropertyObject "base-stream" val++data FilterInputStreamBaseStreamPropertyInfo+instance AttrInfo FilterInputStreamBaseStreamPropertyInfo where+    type AttrAllowedOps FilterInputStreamBaseStreamPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FilterInputStreamBaseStreamPropertyInfo = InputStreamK+    type AttrBaseTypeConstraint FilterInputStreamBaseStreamPropertyInfo = FilterInputStreamK+    type AttrGetType FilterInputStreamBaseStreamPropertyInfo = InputStream+    type AttrLabel FilterInputStreamBaseStreamPropertyInfo = "FilterInputStream::base-stream"+    attrGet _ = getFilterInputStreamBaseStream+    attrSet _ = undefined+    attrConstruct _ = constructFilterInputStreamBaseStream++-- VVV Prop "close-base-stream"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getFilterInputStreamCloseBaseStream :: (MonadIO m, FilterInputStreamK o) => o -> m Bool+getFilterInputStreamCloseBaseStream obj = liftIO $ getObjectPropertyBool obj "close-base-stream"++setFilterInputStreamCloseBaseStream :: (MonadIO m, FilterInputStreamK o) => o -> Bool -> m ()+setFilterInputStreamCloseBaseStream obj val = liftIO $ setObjectPropertyBool obj "close-base-stream" val++constructFilterInputStreamCloseBaseStream :: Bool -> IO ([Char], GValue)+constructFilterInputStreamCloseBaseStream val = constructObjectPropertyBool "close-base-stream" val++data FilterInputStreamCloseBaseStreamPropertyInfo+instance AttrInfo FilterInputStreamCloseBaseStreamPropertyInfo where+    type AttrAllowedOps FilterInputStreamCloseBaseStreamPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FilterInputStreamCloseBaseStreamPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint FilterInputStreamCloseBaseStreamPropertyInfo = FilterInputStreamK+    type AttrGetType FilterInputStreamCloseBaseStreamPropertyInfo = Bool+    type AttrLabel FilterInputStreamCloseBaseStreamPropertyInfo = "FilterInputStream::close-base-stream"+    attrGet _ = getFilterInputStreamCloseBaseStream+    attrSet _ = setFilterInputStreamCloseBaseStream+    attrConstruct _ = constructFilterInputStreamCloseBaseStream++type instance AttributeList FilterInputStream = FilterInputStreamAttributeList+type FilterInputStreamAttributeList = ('[ '("base-stream", FilterInputStreamBaseStreamPropertyInfo), '("close-base-stream", FilterInputStreamCloseBaseStreamPropertyInfo)] :: [(Symbol, *)])++type instance SignalList FilterInputStream = FilterInputStreamSignalList+type FilterInputStreamSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method FilterInputStream::get_base_stream+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FilterInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FilterInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "InputStream"+-- throws : False+-- Skip return : False++foreign import ccall "g_filter_input_stream_get_base_stream" g_filter_input_stream_get_base_stream :: +    Ptr FilterInputStream ->                -- _obj : TInterface "Gio" "FilterInputStream"+    IO (Ptr InputStream)+++filterInputStreamGetBaseStream ::+    (MonadIO m, FilterInputStreamK a) =>+    a ->                                    -- _obj+    m InputStream+filterInputStreamGetBaseStream _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_filter_input_stream_get_base_stream _obj'+    checkUnexpectedReturnNULL "g_filter_input_stream_get_base_stream" result+    result' <- (newObject InputStream) result+    touchManagedPtr _obj+    return result'++-- method FilterInputStream::get_close_base_stream+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FilterInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FilterInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_filter_input_stream_get_close_base_stream" g_filter_input_stream_get_close_base_stream :: +    Ptr FilterInputStream ->                -- _obj : TInterface "Gio" "FilterInputStream"+    IO CInt+++filterInputStreamGetCloseBaseStream ::+    (MonadIO m, FilterInputStreamK a) =>+    a ->                                    -- _obj+    m Bool+filterInputStreamGetCloseBaseStream _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_filter_input_stream_get_close_base_stream _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FilterInputStream::set_close_base_stream+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FilterInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "close_base", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FilterInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "close_base", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_filter_input_stream_set_close_base_stream" g_filter_input_stream_set_close_base_stream :: +    Ptr FilterInputStream ->                -- _obj : TInterface "Gio" "FilterInputStream"+    CInt ->                                 -- close_base : TBasicType TBoolean+    IO ()+++filterInputStreamSetCloseBaseStream ::+    (MonadIO m, FilterInputStreamK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- close_base+    m ()+filterInputStreamSetCloseBaseStream _obj close_base = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let close_base' = (fromIntegral . fromEnum) close_base+    g_filter_input_stream_set_close_base_stream _obj' close_base'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Objects/FilterInputStream.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gio.Objects.FilterInputStream where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype FilterInputStream = FilterInputStream (ForeignPtr FilterInputStream)+instance GObject FilterInputStream where+class GObject o => FilterInputStreamK o+instance (GObject o, IsDescendantOf FilterInputStream o) => FilterInputStreamK o+data FilterInputStreamBaseStreamPropertyInfo+data FilterInputStreamCloseBaseStreamPropertyInfo
+ GI/Gio/Objects/FilterOutputStream.hs view
@@ -0,0 +1,208 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.FilterOutputStream+    ( ++-- * Exported types+    FilterOutputStream(..)                  ,+    FilterOutputStreamK                     ,+    toFilterOutputStream                    ,+    noFilterOutputStream                    ,+++ -- * Methods+-- ** filterOutputStreamGetBaseStream+    filterOutputStreamGetBaseStream         ,+++-- ** filterOutputStreamGetCloseBaseStream+    filterOutputStreamGetCloseBaseStream    ,+++-- ** filterOutputStreamSetCloseBaseStream+    filterOutputStreamSetCloseBaseStream    ,+++++ -- * Properties+-- ** BaseStream+    FilterOutputStreamBaseStreamPropertyInfo,+    constructFilterOutputStreamBaseStream   ,+    getFilterOutputStreamBaseStream         ,+++-- ** CloseBaseStream+    FilterOutputStreamCloseBaseStreamPropertyInfo,+    constructFilterOutputStreamCloseBaseStream,+    getFilterOutputStreamCloseBaseStream    ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype FilterOutputStream = FilterOutputStream (ForeignPtr FilterOutputStream)+foreign import ccall "g_filter_output_stream_get_type"+    c_g_filter_output_stream_get_type :: IO GType++type instance ParentTypes FilterOutputStream = FilterOutputStreamParentTypes+type FilterOutputStreamParentTypes = '[OutputStream, GObject.Object]++instance GObject FilterOutputStream where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_filter_output_stream_get_type+    ++class GObject o => FilterOutputStreamK o+instance (GObject o, IsDescendantOf FilterOutputStream o) => FilterOutputStreamK o++toFilterOutputStream :: FilterOutputStreamK o => o -> IO FilterOutputStream+toFilterOutputStream = unsafeCastTo FilterOutputStream++noFilterOutputStream :: Maybe FilterOutputStream+noFilterOutputStream = Nothing++-- VVV Prop "base-stream"+   -- Type: TInterface "Gio" "OutputStream"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getFilterOutputStreamBaseStream :: (MonadIO m, FilterOutputStreamK o) => o -> m OutputStream+getFilterOutputStreamBaseStream obj = liftIO $ getObjectPropertyObject obj "base-stream" OutputStream++constructFilterOutputStreamBaseStream :: (OutputStreamK a) => a -> IO ([Char], GValue)+constructFilterOutputStreamBaseStream val = constructObjectPropertyObject "base-stream" val++data FilterOutputStreamBaseStreamPropertyInfo+instance AttrInfo FilterOutputStreamBaseStreamPropertyInfo where+    type AttrAllowedOps FilterOutputStreamBaseStreamPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FilterOutputStreamBaseStreamPropertyInfo = OutputStreamK+    type AttrBaseTypeConstraint FilterOutputStreamBaseStreamPropertyInfo = FilterOutputStreamK+    type AttrGetType FilterOutputStreamBaseStreamPropertyInfo = OutputStream+    type AttrLabel FilterOutputStreamBaseStreamPropertyInfo = "FilterOutputStream::base-stream"+    attrGet _ = getFilterOutputStreamBaseStream+    attrSet _ = undefined+    attrConstruct _ = constructFilterOutputStreamBaseStream++-- VVV Prop "close-base-stream"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getFilterOutputStreamCloseBaseStream :: (MonadIO m, FilterOutputStreamK o) => o -> m Bool+getFilterOutputStreamCloseBaseStream obj = liftIO $ getObjectPropertyBool obj "close-base-stream"++constructFilterOutputStreamCloseBaseStream :: Bool -> IO ([Char], GValue)+constructFilterOutputStreamCloseBaseStream val = constructObjectPropertyBool "close-base-stream" val++data FilterOutputStreamCloseBaseStreamPropertyInfo+instance AttrInfo FilterOutputStreamCloseBaseStreamPropertyInfo where+    type AttrAllowedOps FilterOutputStreamCloseBaseStreamPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FilterOutputStreamCloseBaseStreamPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint FilterOutputStreamCloseBaseStreamPropertyInfo = FilterOutputStreamK+    type AttrGetType FilterOutputStreamCloseBaseStreamPropertyInfo = Bool+    type AttrLabel FilterOutputStreamCloseBaseStreamPropertyInfo = "FilterOutputStream::close-base-stream"+    attrGet _ = getFilterOutputStreamCloseBaseStream+    attrSet _ = undefined+    attrConstruct _ = constructFilterOutputStreamCloseBaseStream++type instance AttributeList FilterOutputStream = FilterOutputStreamAttributeList+type FilterOutputStreamAttributeList = ('[ '("base-stream", FilterOutputStreamBaseStreamPropertyInfo), '("close-base-stream", FilterOutputStreamCloseBaseStreamPropertyInfo)] :: [(Symbol, *)])++type instance SignalList FilterOutputStream = FilterOutputStreamSignalList+type FilterOutputStreamSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method FilterOutputStream::get_base_stream+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FilterOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FilterOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "OutputStream"+-- throws : False+-- Skip return : False++foreign import ccall "g_filter_output_stream_get_base_stream" g_filter_output_stream_get_base_stream :: +    Ptr FilterOutputStream ->               -- _obj : TInterface "Gio" "FilterOutputStream"+    IO (Ptr OutputStream)+++filterOutputStreamGetBaseStream ::+    (MonadIO m, FilterOutputStreamK a) =>+    a ->                                    -- _obj+    m OutputStream+filterOutputStreamGetBaseStream _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_filter_output_stream_get_base_stream _obj'+    checkUnexpectedReturnNULL "g_filter_output_stream_get_base_stream" result+    result' <- (newObject OutputStream) result+    touchManagedPtr _obj+    return result'++-- method FilterOutputStream::get_close_base_stream+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FilterOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FilterOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_filter_output_stream_get_close_base_stream" g_filter_output_stream_get_close_base_stream :: +    Ptr FilterOutputStream ->               -- _obj : TInterface "Gio" "FilterOutputStream"+    IO CInt+++filterOutputStreamGetCloseBaseStream ::+    (MonadIO m, FilterOutputStreamK a) =>+    a ->                                    -- _obj+    m Bool+filterOutputStreamGetCloseBaseStream _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_filter_output_stream_get_close_base_stream _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FilterOutputStream::set_close_base_stream+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FilterOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "close_base", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FilterOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "close_base", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_filter_output_stream_set_close_base_stream" g_filter_output_stream_set_close_base_stream :: +    Ptr FilterOutputStream ->               -- _obj : TInterface "Gio" "FilterOutputStream"+    CInt ->                                 -- close_base : TBasicType TBoolean+    IO ()+++filterOutputStreamSetCloseBaseStream ::+    (MonadIO m, FilterOutputStreamK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- close_base+    m ()+filterOutputStreamSetCloseBaseStream _obj close_base = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let close_base' = (fromIntegral . fromEnum) close_base+    g_filter_output_stream_set_close_base_stream _obj' close_base'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Objects/FilterOutputStream.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gio.Objects.FilterOutputStream where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype FilterOutputStream = FilterOutputStream (ForeignPtr FilterOutputStream)+instance GObject FilterOutputStream where+class GObject o => FilterOutputStreamK o+instance (GObject o, IsDescendantOf FilterOutputStream o) => FilterOutputStreamK o+data FilterOutputStreamBaseStreamPropertyInfo+data FilterOutputStreamCloseBaseStreamPropertyInfo
+ GI/Gio/Objects/IOStream.hs view
@@ -0,0 +1,528 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.IOStream+    ( ++-- * Exported types+    IOStream(..)                            ,+    IOStreamK                               ,+    toIOStream                              ,+    noIOStream                              ,+++ -- * Methods+-- ** iOStreamClearPending+    iOStreamClearPending                    ,+++-- ** iOStreamClose+    iOStreamClose                           ,+++-- ** iOStreamCloseAsync+    iOStreamCloseAsync                      ,+++-- ** iOStreamCloseFinish+    iOStreamCloseFinish                     ,+++-- ** iOStreamGetInputStream+    iOStreamGetInputStream                  ,+++-- ** iOStreamGetOutputStream+    iOStreamGetOutputStream                 ,+++-- ** iOStreamHasPending+    iOStreamHasPending                      ,+++-- ** iOStreamIsClosed+    iOStreamIsClosed                        ,+++-- ** iOStreamSetPending+    iOStreamSetPending                      ,+++-- ** iOStreamSpliceAsync+    iOStreamSpliceAsync                     ,+++-- ** iOStreamSpliceFinish+    iOStreamSpliceFinish                    ,+++++ -- * Properties+-- ** Closed+    IOStreamClosedPropertyInfo              ,+    getIOStreamClosed                       ,+++-- ** InputStream+    IOStreamInputStreamPropertyInfo         ,+    getIOStreamInputStream                  ,+++-- ** OutputStream+    IOStreamOutputStreamPropertyInfo        ,+    getIOStreamOutputStream                 ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype IOStream = IOStream (ForeignPtr IOStream)+foreign import ccall "g_io_stream_get_type"+    c_g_io_stream_get_type :: IO GType++type instance ParentTypes IOStream = IOStreamParentTypes+type IOStreamParentTypes = '[GObject.Object]++instance GObject IOStream where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_io_stream_get_type+    ++class GObject o => IOStreamK o+instance (GObject o, IsDescendantOf IOStream o) => IOStreamK o++toIOStream :: IOStreamK o => o -> IO IOStream+toIOStream = unsafeCastTo IOStream++noIOStream :: Maybe IOStream+noIOStream = Nothing++-- VVV Prop "closed"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getIOStreamClosed :: (MonadIO m, IOStreamK o) => o -> m Bool+getIOStreamClosed obj = liftIO $ getObjectPropertyBool obj "closed"++data IOStreamClosedPropertyInfo+instance AttrInfo IOStreamClosedPropertyInfo where+    type AttrAllowedOps IOStreamClosedPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint IOStreamClosedPropertyInfo = (~) ()+    type AttrBaseTypeConstraint IOStreamClosedPropertyInfo = IOStreamK+    type AttrGetType IOStreamClosedPropertyInfo = Bool+    type AttrLabel IOStreamClosedPropertyInfo = "IOStream::closed"+    attrGet _ = getIOStreamClosed+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "input-stream"+   -- Type: TInterface "Gio" "InputStream"+   -- Flags: [PropertyReadable]++getIOStreamInputStream :: (MonadIO m, IOStreamK o) => o -> m InputStream+getIOStreamInputStream obj = liftIO $ getObjectPropertyObject obj "input-stream" InputStream++data IOStreamInputStreamPropertyInfo+instance AttrInfo IOStreamInputStreamPropertyInfo where+    type AttrAllowedOps IOStreamInputStreamPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint IOStreamInputStreamPropertyInfo = (~) ()+    type AttrBaseTypeConstraint IOStreamInputStreamPropertyInfo = IOStreamK+    type AttrGetType IOStreamInputStreamPropertyInfo = InputStream+    type AttrLabel IOStreamInputStreamPropertyInfo = "IOStream::input-stream"+    attrGet _ = getIOStreamInputStream+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "output-stream"+   -- Type: TInterface "Gio" "OutputStream"+   -- Flags: [PropertyReadable]++getIOStreamOutputStream :: (MonadIO m, IOStreamK o) => o -> m OutputStream+getIOStreamOutputStream obj = liftIO $ getObjectPropertyObject obj "output-stream" OutputStream++data IOStreamOutputStreamPropertyInfo+instance AttrInfo IOStreamOutputStreamPropertyInfo where+    type AttrAllowedOps IOStreamOutputStreamPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint IOStreamOutputStreamPropertyInfo = (~) ()+    type AttrBaseTypeConstraint IOStreamOutputStreamPropertyInfo = IOStreamK+    type AttrGetType IOStreamOutputStreamPropertyInfo = OutputStream+    type AttrLabel IOStreamOutputStreamPropertyInfo = "IOStream::output-stream"+    attrGet _ = getIOStreamOutputStream+    attrSet _ = undefined+    attrConstruct _ = undefined++type instance AttributeList IOStream = IOStreamAttributeList+type IOStreamAttributeList = ('[ '("closed", IOStreamClosedPropertyInfo), '("input-stream", IOStreamInputStreamPropertyInfo), '("output-stream", IOStreamOutputStreamPropertyInfo)] :: [(Symbol, *)])++type instance SignalList IOStream = IOStreamSignalList+type IOStreamSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method IOStream::clear_pending+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_io_stream_clear_pending" g_io_stream_clear_pending :: +    Ptr IOStream ->                         -- _obj : TInterface "Gio" "IOStream"+    IO ()+++iOStreamClearPending ::+    (MonadIO m, IOStreamK a) =>+    a ->                                    -- _obj+    m ()+iOStreamClearPending _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_io_stream_clear_pending _obj'+    touchManagedPtr _obj+    return ()++-- method IOStream::close+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_io_stream_close" g_io_stream_close :: +    Ptr IOStream ->                         -- _obj : TInterface "Gio" "IOStream"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++iOStreamClose ::+    (MonadIO m, IOStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m ()+iOStreamClose _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_io_stream_close _obj' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method IOStream::close_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_io_stream_close_async" g_io_stream_close_async :: +    Ptr IOStream ->                         -- _obj : TInterface "Gio" "IOStream"+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++iOStreamCloseAsync ::+    (MonadIO m, IOStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+iOStreamCloseAsync _obj io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_io_stream_close_async _obj' io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method IOStream::close_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_io_stream_close_finish" g_io_stream_close_finish :: +    Ptr IOStream ->                         -- _obj : TInterface "Gio" "IOStream"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++iOStreamCloseFinish ::+    (MonadIO m, IOStreamK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+iOStreamCloseFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_io_stream_close_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++-- method IOStream::get_input_stream+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "InputStream"+-- throws : False+-- Skip return : False++foreign import ccall "g_io_stream_get_input_stream" g_io_stream_get_input_stream :: +    Ptr IOStream ->                         -- _obj : TInterface "Gio" "IOStream"+    IO (Ptr InputStream)+++iOStreamGetInputStream ::+    (MonadIO m, IOStreamK a) =>+    a ->                                    -- _obj+    m InputStream+iOStreamGetInputStream _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_io_stream_get_input_stream _obj'+    checkUnexpectedReturnNULL "g_io_stream_get_input_stream" result+    result' <- (newObject InputStream) result+    touchManagedPtr _obj+    return result'++-- method IOStream::get_output_stream+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "OutputStream"+-- throws : False+-- Skip return : False++foreign import ccall "g_io_stream_get_output_stream" g_io_stream_get_output_stream :: +    Ptr IOStream ->                         -- _obj : TInterface "Gio" "IOStream"+    IO (Ptr OutputStream)+++iOStreamGetOutputStream ::+    (MonadIO m, IOStreamK a) =>+    a ->                                    -- _obj+    m OutputStream+iOStreamGetOutputStream _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_io_stream_get_output_stream _obj'+    checkUnexpectedReturnNULL "g_io_stream_get_output_stream" result+    result' <- (newObject OutputStream) result+    touchManagedPtr _obj+    return result'++-- method IOStream::has_pending+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_io_stream_has_pending" g_io_stream_has_pending :: +    Ptr IOStream ->                         -- _obj : TInterface "Gio" "IOStream"+    IO CInt+++iOStreamHasPending ::+    (MonadIO m, IOStreamK a) =>+    a ->                                    -- _obj+    m Bool+iOStreamHasPending _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_io_stream_has_pending _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method IOStream::is_closed+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_io_stream_is_closed" g_io_stream_is_closed :: +    Ptr IOStream ->                         -- _obj : TInterface "Gio" "IOStream"+    IO CInt+++iOStreamIsClosed ::+    (MonadIO m, IOStreamK a) =>+    a ->                                    -- _obj+    m Bool+iOStreamIsClosed _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_io_stream_is_closed _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method IOStream::set_pending+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_io_stream_set_pending" g_io_stream_set_pending :: +    Ptr IOStream ->                         -- _obj : TInterface "Gio" "IOStream"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++iOStreamSetPending ::+    (MonadIO m, IOStreamK a) =>+    a ->                                    -- _obj+    m ()+iOStreamSetPending _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    onException (do+        _ <- propagateGError $ g_io_stream_set_pending _obj'+        touchManagedPtr _obj+        return ()+     ) (do+        return ()+     )++-- method IOStream::splice_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stream2", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "IOStreamSpliceFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stream2", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "IOStreamSpliceFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_io_stream_splice_async" g_io_stream_splice_async :: +    Ptr IOStream ->                         -- _obj : TInterface "Gio" "IOStream"+    Ptr IOStream ->                         -- stream2 : TInterface "Gio" "IOStream"+    CUInt ->                                -- flags : TInterface "Gio" "IOStreamSpliceFlags"+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++iOStreamSpliceAsync ::+    (MonadIO m, IOStreamK a, IOStreamK b, CancellableK c) =>+    a ->                                    -- _obj+    b ->                                    -- stream2+    [IOStreamSpliceFlags] ->                -- flags+    Int32 ->                                -- io_priority+    Maybe (c) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+iOStreamSpliceAsync _obj stream2 flags io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let stream2' = unsafeManagedPtrCastPtr stream2+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_io_stream_splice_async _obj' stream2' flags' io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    touchManagedPtr stream2+    whenJust cancellable touchManagedPtr+    return ()++-- method IOStream::splice_finish+-- method type : MemberFunction+-- Args : [Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_io_stream_splice_finish" g_io_stream_splice_finish :: +    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++iOStreamSpliceFinish ::+    (MonadIO m, AsyncResultK a) =>+    a ->                                    -- result+    m ()+iOStreamSpliceFinish result_ = liftIO $ do+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_io_stream_splice_finish result_'+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++
+ GI/Gio/Objects/IOStream.hs-boot view
@@ -0,0 +1,16 @@+module GI.Gio.Objects.IOStream where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype IOStream = IOStream (ForeignPtr IOStream)+instance GObject IOStream where+class GObject o => IOStreamK o+instance (GObject o, IsDescendantOf IOStream o) => IOStreamK o+data IOStreamClosedPropertyInfo+data IOStreamInputStreamPropertyInfo+data IOStreamOutputStreamPropertyInfo
+ GI/Gio/Objects/InetAddress.hs view
@@ -0,0 +1,878 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.InetAddress+    ( ++-- * Exported types+    InetAddress(..)                         ,+    InetAddressK                            ,+    toInetAddress                           ,+    noInetAddress                           ,+++ -- * Methods+-- ** inetAddressEqual+    inetAddressEqual                        ,+++-- ** inetAddressGetFamily+    inetAddressGetFamily                    ,+++-- ** inetAddressGetIsAny+    inetAddressGetIsAny                     ,+++-- ** inetAddressGetIsLinkLocal+    inetAddressGetIsLinkLocal               ,+++-- ** inetAddressGetIsLoopback+    inetAddressGetIsLoopback                ,+++-- ** inetAddressGetIsMcGlobal+    inetAddressGetIsMcGlobal                ,+++-- ** inetAddressGetIsMcLinkLocal+    inetAddressGetIsMcLinkLocal             ,+++-- ** inetAddressGetIsMcNodeLocal+    inetAddressGetIsMcNodeLocal             ,+++-- ** inetAddressGetIsMcOrgLocal+    inetAddressGetIsMcOrgLocal              ,+++-- ** inetAddressGetIsMcSiteLocal+    inetAddressGetIsMcSiteLocal             ,+++-- ** inetAddressGetIsMulticast+    inetAddressGetIsMulticast               ,+++-- ** inetAddressGetIsSiteLocal+    inetAddressGetIsSiteLocal               ,+++-- ** inetAddressGetNativeSize+    inetAddressGetNativeSize                ,+++-- ** inetAddressNewAny+    inetAddressNewAny                       ,+++-- ** inetAddressNewFromBytes+    inetAddressNewFromBytes                 ,+++-- ** inetAddressNewFromString+    inetAddressNewFromString                ,+++-- ** inetAddressNewLoopback+    inetAddressNewLoopback                  ,+++-- ** inetAddressToString+    inetAddressToString                     ,+++++ -- * Properties+-- ** Bytes+    InetAddressBytesPropertyInfo            ,+    constructInetAddressBytes               ,+    getInetAddressBytes                     ,+++-- ** Family+    InetAddressFamilyPropertyInfo           ,+    constructInetAddressFamily              ,+    getInetAddressFamily                    ,+++-- ** IsAny+    InetAddressIsAnyPropertyInfo            ,+    getInetAddressIsAny                     ,+++-- ** IsLinkLocal+    InetAddressIsLinkLocalPropertyInfo      ,+    getInetAddressIsLinkLocal               ,+++-- ** IsLoopback+    InetAddressIsLoopbackPropertyInfo       ,+    getInetAddressIsLoopback                ,+++-- ** IsMcGlobal+    InetAddressIsMcGlobalPropertyInfo       ,+    getInetAddressIsMcGlobal                ,+++-- ** IsMcLinkLocal+    InetAddressIsMcLinkLocalPropertyInfo    ,+    getInetAddressIsMcLinkLocal             ,+++-- ** IsMcNodeLocal+    InetAddressIsMcNodeLocalPropertyInfo    ,+    getInetAddressIsMcNodeLocal             ,+++-- ** IsMcOrgLocal+    InetAddressIsMcOrgLocalPropertyInfo     ,+    getInetAddressIsMcOrgLocal              ,+++-- ** IsMcSiteLocal+    InetAddressIsMcSiteLocalPropertyInfo    ,+    getInetAddressIsMcSiteLocal             ,+++-- ** IsMulticast+    InetAddressIsMulticastPropertyInfo      ,+    getInetAddressIsMulticast               ,+++-- ** IsSiteLocal+    InetAddressIsSiteLocalPropertyInfo      ,+    getInetAddressIsSiteLocal               ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype InetAddress = InetAddress (ForeignPtr InetAddress)+foreign import ccall "g_inet_address_get_type"+    c_g_inet_address_get_type :: IO GType++type instance ParentTypes InetAddress = InetAddressParentTypes+type InetAddressParentTypes = '[GObject.Object]++instance GObject InetAddress where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_inet_address_get_type+    ++class GObject o => InetAddressK o+instance (GObject o, IsDescendantOf InetAddress o) => InetAddressK o++toInetAddress :: InetAddressK o => o -> IO InetAddress+toInetAddress = unsafeCastTo InetAddress++noInetAddress :: Maybe InetAddress+noInetAddress = Nothing++-- VVV Prop "bytes"+   -- Type: TBasicType TVoid+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getInetAddressBytes :: (MonadIO m, InetAddressK o) => o -> m (Ptr ())+getInetAddressBytes obj = liftIO $ getObjectPropertyPtr obj "bytes"++constructInetAddressBytes :: (Ptr ()) -> IO ([Char], GValue)+constructInetAddressBytes val = constructObjectPropertyPtr "bytes" val++data InetAddressBytesPropertyInfo+instance AttrInfo InetAddressBytesPropertyInfo where+    type AttrAllowedOps InetAddressBytesPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint InetAddressBytesPropertyInfo = (~) (Ptr ())+    type AttrBaseTypeConstraint InetAddressBytesPropertyInfo = InetAddressK+    type AttrGetType InetAddressBytesPropertyInfo = (Ptr ())+    type AttrLabel InetAddressBytesPropertyInfo = "InetAddress::bytes"+    attrGet _ = getInetAddressBytes+    attrSet _ = undefined+    attrConstruct _ = constructInetAddressBytes++-- VVV Prop "family"+   -- Type: TInterface "Gio" "SocketFamily"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getInetAddressFamily :: (MonadIO m, InetAddressK o) => o -> m SocketFamily+getInetAddressFamily obj = liftIO $ getObjectPropertyEnum obj "family"++constructInetAddressFamily :: SocketFamily -> IO ([Char], GValue)+constructInetAddressFamily val = constructObjectPropertyEnum "family" val++data InetAddressFamilyPropertyInfo+instance AttrInfo InetAddressFamilyPropertyInfo where+    type AttrAllowedOps InetAddressFamilyPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint InetAddressFamilyPropertyInfo = (~) SocketFamily+    type AttrBaseTypeConstraint InetAddressFamilyPropertyInfo = InetAddressK+    type AttrGetType InetAddressFamilyPropertyInfo = SocketFamily+    type AttrLabel InetAddressFamilyPropertyInfo = "InetAddress::family"+    attrGet _ = getInetAddressFamily+    attrSet _ = undefined+    attrConstruct _ = constructInetAddressFamily++-- VVV Prop "is-any"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getInetAddressIsAny :: (MonadIO m, InetAddressK o) => o -> m Bool+getInetAddressIsAny obj = liftIO $ getObjectPropertyBool obj "is-any"++data InetAddressIsAnyPropertyInfo+instance AttrInfo InetAddressIsAnyPropertyInfo where+    type AttrAllowedOps InetAddressIsAnyPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint InetAddressIsAnyPropertyInfo = (~) ()+    type AttrBaseTypeConstraint InetAddressIsAnyPropertyInfo = InetAddressK+    type AttrGetType InetAddressIsAnyPropertyInfo = Bool+    type AttrLabel InetAddressIsAnyPropertyInfo = "InetAddress::is-any"+    attrGet _ = getInetAddressIsAny+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "is-link-local"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getInetAddressIsLinkLocal :: (MonadIO m, InetAddressK o) => o -> m Bool+getInetAddressIsLinkLocal obj = liftIO $ getObjectPropertyBool obj "is-link-local"++data InetAddressIsLinkLocalPropertyInfo+instance AttrInfo InetAddressIsLinkLocalPropertyInfo where+    type AttrAllowedOps InetAddressIsLinkLocalPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint InetAddressIsLinkLocalPropertyInfo = (~) ()+    type AttrBaseTypeConstraint InetAddressIsLinkLocalPropertyInfo = InetAddressK+    type AttrGetType InetAddressIsLinkLocalPropertyInfo = Bool+    type AttrLabel InetAddressIsLinkLocalPropertyInfo = "InetAddress::is-link-local"+    attrGet _ = getInetAddressIsLinkLocal+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "is-loopback"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getInetAddressIsLoopback :: (MonadIO m, InetAddressK o) => o -> m Bool+getInetAddressIsLoopback obj = liftIO $ getObjectPropertyBool obj "is-loopback"++data InetAddressIsLoopbackPropertyInfo+instance AttrInfo InetAddressIsLoopbackPropertyInfo where+    type AttrAllowedOps InetAddressIsLoopbackPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint InetAddressIsLoopbackPropertyInfo = (~) ()+    type AttrBaseTypeConstraint InetAddressIsLoopbackPropertyInfo = InetAddressK+    type AttrGetType InetAddressIsLoopbackPropertyInfo = Bool+    type AttrLabel InetAddressIsLoopbackPropertyInfo = "InetAddress::is-loopback"+    attrGet _ = getInetAddressIsLoopback+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "is-mc-global"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getInetAddressIsMcGlobal :: (MonadIO m, InetAddressK o) => o -> m Bool+getInetAddressIsMcGlobal obj = liftIO $ getObjectPropertyBool obj "is-mc-global"++data InetAddressIsMcGlobalPropertyInfo+instance AttrInfo InetAddressIsMcGlobalPropertyInfo where+    type AttrAllowedOps InetAddressIsMcGlobalPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint InetAddressIsMcGlobalPropertyInfo = (~) ()+    type AttrBaseTypeConstraint InetAddressIsMcGlobalPropertyInfo = InetAddressK+    type AttrGetType InetAddressIsMcGlobalPropertyInfo = Bool+    type AttrLabel InetAddressIsMcGlobalPropertyInfo = "InetAddress::is-mc-global"+    attrGet _ = getInetAddressIsMcGlobal+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "is-mc-link-local"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getInetAddressIsMcLinkLocal :: (MonadIO m, InetAddressK o) => o -> m Bool+getInetAddressIsMcLinkLocal obj = liftIO $ getObjectPropertyBool obj "is-mc-link-local"++data InetAddressIsMcLinkLocalPropertyInfo+instance AttrInfo InetAddressIsMcLinkLocalPropertyInfo where+    type AttrAllowedOps InetAddressIsMcLinkLocalPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint InetAddressIsMcLinkLocalPropertyInfo = (~) ()+    type AttrBaseTypeConstraint InetAddressIsMcLinkLocalPropertyInfo = InetAddressK+    type AttrGetType InetAddressIsMcLinkLocalPropertyInfo = Bool+    type AttrLabel InetAddressIsMcLinkLocalPropertyInfo = "InetAddress::is-mc-link-local"+    attrGet _ = getInetAddressIsMcLinkLocal+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "is-mc-node-local"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getInetAddressIsMcNodeLocal :: (MonadIO m, InetAddressK o) => o -> m Bool+getInetAddressIsMcNodeLocal obj = liftIO $ getObjectPropertyBool obj "is-mc-node-local"++data InetAddressIsMcNodeLocalPropertyInfo+instance AttrInfo InetAddressIsMcNodeLocalPropertyInfo where+    type AttrAllowedOps InetAddressIsMcNodeLocalPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint InetAddressIsMcNodeLocalPropertyInfo = (~) ()+    type AttrBaseTypeConstraint InetAddressIsMcNodeLocalPropertyInfo = InetAddressK+    type AttrGetType InetAddressIsMcNodeLocalPropertyInfo = Bool+    type AttrLabel InetAddressIsMcNodeLocalPropertyInfo = "InetAddress::is-mc-node-local"+    attrGet _ = getInetAddressIsMcNodeLocal+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "is-mc-org-local"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getInetAddressIsMcOrgLocal :: (MonadIO m, InetAddressK o) => o -> m Bool+getInetAddressIsMcOrgLocal obj = liftIO $ getObjectPropertyBool obj "is-mc-org-local"++data InetAddressIsMcOrgLocalPropertyInfo+instance AttrInfo InetAddressIsMcOrgLocalPropertyInfo where+    type AttrAllowedOps InetAddressIsMcOrgLocalPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint InetAddressIsMcOrgLocalPropertyInfo = (~) ()+    type AttrBaseTypeConstraint InetAddressIsMcOrgLocalPropertyInfo = InetAddressK+    type AttrGetType InetAddressIsMcOrgLocalPropertyInfo = Bool+    type AttrLabel InetAddressIsMcOrgLocalPropertyInfo = "InetAddress::is-mc-org-local"+    attrGet _ = getInetAddressIsMcOrgLocal+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "is-mc-site-local"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getInetAddressIsMcSiteLocal :: (MonadIO m, InetAddressK o) => o -> m Bool+getInetAddressIsMcSiteLocal obj = liftIO $ getObjectPropertyBool obj "is-mc-site-local"++data InetAddressIsMcSiteLocalPropertyInfo+instance AttrInfo InetAddressIsMcSiteLocalPropertyInfo where+    type AttrAllowedOps InetAddressIsMcSiteLocalPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint InetAddressIsMcSiteLocalPropertyInfo = (~) ()+    type AttrBaseTypeConstraint InetAddressIsMcSiteLocalPropertyInfo = InetAddressK+    type AttrGetType InetAddressIsMcSiteLocalPropertyInfo = Bool+    type AttrLabel InetAddressIsMcSiteLocalPropertyInfo = "InetAddress::is-mc-site-local"+    attrGet _ = getInetAddressIsMcSiteLocal+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "is-multicast"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getInetAddressIsMulticast :: (MonadIO m, InetAddressK o) => o -> m Bool+getInetAddressIsMulticast obj = liftIO $ getObjectPropertyBool obj "is-multicast"++data InetAddressIsMulticastPropertyInfo+instance AttrInfo InetAddressIsMulticastPropertyInfo where+    type AttrAllowedOps InetAddressIsMulticastPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint InetAddressIsMulticastPropertyInfo = (~) ()+    type AttrBaseTypeConstraint InetAddressIsMulticastPropertyInfo = InetAddressK+    type AttrGetType InetAddressIsMulticastPropertyInfo = Bool+    type AttrLabel InetAddressIsMulticastPropertyInfo = "InetAddress::is-multicast"+    attrGet _ = getInetAddressIsMulticast+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "is-site-local"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getInetAddressIsSiteLocal :: (MonadIO m, InetAddressK o) => o -> m Bool+getInetAddressIsSiteLocal obj = liftIO $ getObjectPropertyBool obj "is-site-local"++data InetAddressIsSiteLocalPropertyInfo+instance AttrInfo InetAddressIsSiteLocalPropertyInfo where+    type AttrAllowedOps InetAddressIsSiteLocalPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint InetAddressIsSiteLocalPropertyInfo = (~) ()+    type AttrBaseTypeConstraint InetAddressIsSiteLocalPropertyInfo = InetAddressK+    type AttrGetType InetAddressIsSiteLocalPropertyInfo = Bool+    type AttrLabel InetAddressIsSiteLocalPropertyInfo = "InetAddress::is-site-local"+    attrGet _ = getInetAddressIsSiteLocal+    attrSet _ = undefined+    attrConstruct _ = undefined++type instance AttributeList InetAddress = InetAddressAttributeList+type InetAddressAttributeList = ('[ '("bytes", InetAddressBytesPropertyInfo), '("family", InetAddressFamilyPropertyInfo), '("is-any", InetAddressIsAnyPropertyInfo), '("is-link-local", InetAddressIsLinkLocalPropertyInfo), '("is-loopback", InetAddressIsLoopbackPropertyInfo), '("is-mc-global", InetAddressIsMcGlobalPropertyInfo), '("is-mc-link-local", InetAddressIsMcLinkLocalPropertyInfo), '("is-mc-node-local", InetAddressIsMcNodeLocalPropertyInfo), '("is-mc-org-local", InetAddressIsMcOrgLocalPropertyInfo), '("is-mc-site-local", InetAddressIsMcSiteLocalPropertyInfo), '("is-multicast", InetAddressIsMulticastPropertyInfo), '("is-site-local", InetAddressIsSiteLocalPropertyInfo)] :: [(Symbol, *)])++type instance SignalList InetAddress = InetAddressSignalList+type InetAddressSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method InetAddress::new_any+-- method type : Constructor+-- Args : [Arg {argName = "family", argType = TInterface "Gio" "SocketFamily", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "family", argType = TInterface "Gio" "SocketFamily", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "InetAddress"+-- throws : False+-- Skip return : False++foreign import ccall "g_inet_address_new_any" g_inet_address_new_any :: +    CUInt ->                                -- family : TInterface "Gio" "SocketFamily"+    IO (Ptr InetAddress)+++inetAddressNewAny ::+    (MonadIO m) =>+    SocketFamily ->                         -- family+    m InetAddress+inetAddressNewAny family = liftIO $ do+    let family' = (fromIntegral . fromEnum) family+    result <- g_inet_address_new_any family'+    checkUnexpectedReturnNULL "g_inet_address_new_any" result+    result' <- (wrapObject InetAddress) result+    return result'++-- method InetAddress::new_from_bytes+-- method type : Constructor+-- Args : [Arg {argName = "bytes", argType = TCArray False (-1) (-1) (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "family", argType = TInterface "Gio" "SocketFamily", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "bytes", argType = TCArray False (-1) (-1) (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "family", argType = TInterface "Gio" "SocketFamily", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "InetAddress"+-- throws : False+-- Skip return : False++foreign import ccall "g_inet_address_new_from_bytes" g_inet_address_new_from_bytes :: +    Ptr Word8 ->                            -- bytes : TCArray False (-1) (-1) (TBasicType TUInt8)+    CUInt ->                                -- family : TInterface "Gio" "SocketFamily"+    IO (Ptr InetAddress)+++inetAddressNewFromBytes ::+    (MonadIO m) =>+    Ptr Word8 ->                            -- bytes+    SocketFamily ->                         -- family+    m InetAddress+inetAddressNewFromBytes bytes family = liftIO $ do+    let family' = (fromIntegral . fromEnum) family+    result <- g_inet_address_new_from_bytes bytes family'+    checkUnexpectedReturnNULL "g_inet_address_new_from_bytes" result+    result' <- (wrapObject InetAddress) result+    return result'++-- method InetAddress::new_from_string+-- method type : Constructor+-- Args : [Arg {argName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "InetAddress"+-- throws : False+-- Skip return : False++foreign import ccall "g_inet_address_new_from_string" g_inet_address_new_from_string :: +    CString ->                              -- string : TBasicType TUTF8+    IO (Ptr InetAddress)+++inetAddressNewFromString ::+    (MonadIO m) =>+    T.Text ->                               -- string+    m InetAddress+inetAddressNewFromString string = liftIO $ do+    string' <- textToCString string+    result <- g_inet_address_new_from_string string'+    checkUnexpectedReturnNULL "g_inet_address_new_from_string" result+    result' <- (wrapObject InetAddress) result+    freeMem string'+    return result'++-- method InetAddress::new_loopback+-- method type : Constructor+-- Args : [Arg {argName = "family", argType = TInterface "Gio" "SocketFamily", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "family", argType = TInterface "Gio" "SocketFamily", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "InetAddress"+-- throws : False+-- Skip return : False++foreign import ccall "g_inet_address_new_loopback" g_inet_address_new_loopback :: +    CUInt ->                                -- family : TInterface "Gio" "SocketFamily"+    IO (Ptr InetAddress)+++inetAddressNewLoopback ::+    (MonadIO m) =>+    SocketFamily ->                         -- family+    m InetAddress+inetAddressNewLoopback family = liftIO $ do+    let family' = (fromIntegral . fromEnum) family+    result <- g_inet_address_new_loopback family'+    checkUnexpectedReturnNULL "g_inet_address_new_loopback" result+    result' <- (wrapObject InetAddress) result+    return result'++-- method InetAddress::equal+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "other_address", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "other_address", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_inet_address_equal" g_inet_address_equal :: +    Ptr InetAddress ->                      -- _obj : TInterface "Gio" "InetAddress"+    Ptr InetAddress ->                      -- other_address : TInterface "Gio" "InetAddress"+    IO CInt+++inetAddressEqual ::+    (MonadIO m, InetAddressK a, InetAddressK b) =>+    a ->                                    -- _obj+    b ->                                    -- other_address+    m Bool+inetAddressEqual _obj other_address = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let other_address' = unsafeManagedPtrCastPtr other_address+    result <- g_inet_address_equal _obj' other_address'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr other_address+    return result'++-- method InetAddress::get_family+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SocketFamily"+-- throws : False+-- Skip return : False++foreign import ccall "g_inet_address_get_family" g_inet_address_get_family :: +    Ptr InetAddress ->                      -- _obj : TInterface "Gio" "InetAddress"+    IO CUInt+++inetAddressGetFamily ::+    (MonadIO m, InetAddressK a) =>+    a ->                                    -- _obj+    m SocketFamily+inetAddressGetFamily _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_inet_address_get_family _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method InetAddress::get_is_any+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_inet_address_get_is_any" g_inet_address_get_is_any :: +    Ptr InetAddress ->                      -- _obj : TInterface "Gio" "InetAddress"+    IO CInt+++inetAddressGetIsAny ::+    (MonadIO m, InetAddressK a) =>+    a ->                                    -- _obj+    m Bool+inetAddressGetIsAny _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_inet_address_get_is_any _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method InetAddress::get_is_link_local+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_inet_address_get_is_link_local" g_inet_address_get_is_link_local :: +    Ptr InetAddress ->                      -- _obj : TInterface "Gio" "InetAddress"+    IO CInt+++inetAddressGetIsLinkLocal ::+    (MonadIO m, InetAddressK a) =>+    a ->                                    -- _obj+    m Bool+inetAddressGetIsLinkLocal _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_inet_address_get_is_link_local _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method InetAddress::get_is_loopback+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_inet_address_get_is_loopback" g_inet_address_get_is_loopback :: +    Ptr InetAddress ->                      -- _obj : TInterface "Gio" "InetAddress"+    IO CInt+++inetAddressGetIsLoopback ::+    (MonadIO m, InetAddressK a) =>+    a ->                                    -- _obj+    m Bool+inetAddressGetIsLoopback _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_inet_address_get_is_loopback _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method InetAddress::get_is_mc_global+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_inet_address_get_is_mc_global" g_inet_address_get_is_mc_global :: +    Ptr InetAddress ->                      -- _obj : TInterface "Gio" "InetAddress"+    IO CInt+++inetAddressGetIsMcGlobal ::+    (MonadIO m, InetAddressK a) =>+    a ->                                    -- _obj+    m Bool+inetAddressGetIsMcGlobal _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_inet_address_get_is_mc_global _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method InetAddress::get_is_mc_link_local+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_inet_address_get_is_mc_link_local" g_inet_address_get_is_mc_link_local :: +    Ptr InetAddress ->                      -- _obj : TInterface "Gio" "InetAddress"+    IO CInt+++inetAddressGetIsMcLinkLocal ::+    (MonadIO m, InetAddressK a) =>+    a ->                                    -- _obj+    m Bool+inetAddressGetIsMcLinkLocal _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_inet_address_get_is_mc_link_local _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method InetAddress::get_is_mc_node_local+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_inet_address_get_is_mc_node_local" g_inet_address_get_is_mc_node_local :: +    Ptr InetAddress ->                      -- _obj : TInterface "Gio" "InetAddress"+    IO CInt+++inetAddressGetIsMcNodeLocal ::+    (MonadIO m, InetAddressK a) =>+    a ->                                    -- _obj+    m Bool+inetAddressGetIsMcNodeLocal _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_inet_address_get_is_mc_node_local _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method InetAddress::get_is_mc_org_local+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_inet_address_get_is_mc_org_local" g_inet_address_get_is_mc_org_local :: +    Ptr InetAddress ->                      -- _obj : TInterface "Gio" "InetAddress"+    IO CInt+++inetAddressGetIsMcOrgLocal ::+    (MonadIO m, InetAddressK a) =>+    a ->                                    -- _obj+    m Bool+inetAddressGetIsMcOrgLocal _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_inet_address_get_is_mc_org_local _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method InetAddress::get_is_mc_site_local+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_inet_address_get_is_mc_site_local" g_inet_address_get_is_mc_site_local :: +    Ptr InetAddress ->                      -- _obj : TInterface "Gio" "InetAddress"+    IO CInt+++inetAddressGetIsMcSiteLocal ::+    (MonadIO m, InetAddressK a) =>+    a ->                                    -- _obj+    m Bool+inetAddressGetIsMcSiteLocal _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_inet_address_get_is_mc_site_local _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method InetAddress::get_is_multicast+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_inet_address_get_is_multicast" g_inet_address_get_is_multicast :: +    Ptr InetAddress ->                      -- _obj : TInterface "Gio" "InetAddress"+    IO CInt+++inetAddressGetIsMulticast ::+    (MonadIO m, InetAddressK a) =>+    a ->                                    -- _obj+    m Bool+inetAddressGetIsMulticast _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_inet_address_get_is_multicast _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method InetAddress::get_is_site_local+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_inet_address_get_is_site_local" g_inet_address_get_is_site_local :: +    Ptr InetAddress ->                      -- _obj : TInterface "Gio" "InetAddress"+    IO CInt+++inetAddressGetIsSiteLocal ::+    (MonadIO m, InetAddressK a) =>+    a ->                                    -- _obj+    m Bool+inetAddressGetIsSiteLocal _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_inet_address_get_is_site_local _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method InetAddress::get_native_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "g_inet_address_get_native_size" g_inet_address_get_native_size :: +    Ptr InetAddress ->                      -- _obj : TInterface "Gio" "InetAddress"+    IO Word64+++inetAddressGetNativeSize ::+    (MonadIO m, InetAddressK a) =>+    a ->                                    -- _obj+    m Word64+inetAddressGetNativeSize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_inet_address_get_native_size _obj'+    touchManagedPtr _obj+    return result++-- method InetAddress::to_string+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_inet_address_to_string" g_inet_address_to_string :: +    Ptr InetAddress ->                      -- _obj : TInterface "Gio" "InetAddress"+    IO CString+++inetAddressToString ::+    (MonadIO m, InetAddressK a) =>+    a ->                                    -- _obj+    m T.Text+inetAddressToString _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_inet_address_to_string _obj'+    checkUnexpectedReturnNULL "g_inet_address_to_string" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++
+ GI/Gio/Objects/InetAddress.hs-boot view
@@ -0,0 +1,25 @@+module GI.Gio.Objects.InetAddress where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype InetAddress = InetAddress (ForeignPtr InetAddress)+instance GObject InetAddress where+class GObject o => InetAddressK o+instance (GObject o, IsDescendantOf InetAddress o) => InetAddressK o+data InetAddressBytesPropertyInfo+data InetAddressFamilyPropertyInfo+data InetAddressIsAnyPropertyInfo+data InetAddressIsLinkLocalPropertyInfo+data InetAddressIsLoopbackPropertyInfo+data InetAddressIsMcGlobalPropertyInfo+data InetAddressIsMcLinkLocalPropertyInfo+data InetAddressIsMcNodeLocalPropertyInfo+data InetAddressIsMcOrgLocalPropertyInfo+data InetAddressIsMcSiteLocalPropertyInfo+data InetAddressIsMulticastPropertyInfo+data InetAddressIsSiteLocalPropertyInfo
+ GI/Gio/Objects/InetAddressMask.hs view
@@ -0,0 +1,405 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.InetAddressMask+    ( ++-- * Exported types+    InetAddressMask(..)                     ,+    InetAddressMaskK                        ,+    toInetAddressMask                       ,+    noInetAddressMask                       ,+++ -- * Methods+-- ** inetAddressMaskEqual+    inetAddressMaskEqual                    ,+++-- ** inetAddressMaskGetAddress+    inetAddressMaskGetAddress               ,+++-- ** inetAddressMaskGetFamily+    inetAddressMaskGetFamily                ,+++-- ** inetAddressMaskGetLength+    inetAddressMaskGetLength                ,+++-- ** inetAddressMaskMatches+    inetAddressMaskMatches                  ,+++-- ** inetAddressMaskNew+    inetAddressMaskNew                      ,+++-- ** inetAddressMaskNewFromString+    inetAddressMaskNewFromString            ,+++-- ** inetAddressMaskToString+    inetAddressMaskToString                 ,+++++ -- * Properties+-- ** Address+    InetAddressMaskAddressPropertyInfo      ,+    constructInetAddressMaskAddress         ,+    getInetAddressMaskAddress               ,+    setInetAddressMaskAddress               ,+++-- ** Family+    InetAddressMaskFamilyPropertyInfo       ,+    getInetAddressMaskFamily                ,+++-- ** Length+    InetAddressMaskLengthPropertyInfo       ,+    constructInetAddressMaskLength          ,+    getInetAddressMaskLength                ,+    setInetAddressMaskLength                ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype InetAddressMask = InetAddressMask (ForeignPtr InetAddressMask)+foreign import ccall "g_inet_address_mask_get_type"+    c_g_inet_address_mask_get_type :: IO GType++type instance ParentTypes InetAddressMask = InetAddressMaskParentTypes+type InetAddressMaskParentTypes = '[GObject.Object, Initable]++instance GObject InetAddressMask where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_inet_address_mask_get_type+    ++class GObject o => InetAddressMaskK o+instance (GObject o, IsDescendantOf InetAddressMask o) => InetAddressMaskK o++toInetAddressMask :: InetAddressMaskK o => o -> IO InetAddressMask+toInetAddressMask = unsafeCastTo InetAddressMask++noInetAddressMask :: Maybe InetAddressMask+noInetAddressMask = Nothing++-- VVV Prop "address"+   -- Type: TInterface "Gio" "InetAddress"+   -- Flags: [PropertyReadable,PropertyWritable]++getInetAddressMaskAddress :: (MonadIO m, InetAddressMaskK o) => o -> m InetAddress+getInetAddressMaskAddress obj = liftIO $ getObjectPropertyObject obj "address" InetAddress++setInetAddressMaskAddress :: (MonadIO m, InetAddressMaskK o, InetAddressK a) => o -> a -> m ()+setInetAddressMaskAddress obj val = liftIO $ setObjectPropertyObject obj "address" val++constructInetAddressMaskAddress :: (InetAddressK a) => a -> IO ([Char], GValue)+constructInetAddressMaskAddress val = constructObjectPropertyObject "address" val++data InetAddressMaskAddressPropertyInfo+instance AttrInfo InetAddressMaskAddressPropertyInfo where+    type AttrAllowedOps InetAddressMaskAddressPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint InetAddressMaskAddressPropertyInfo = InetAddressK+    type AttrBaseTypeConstraint InetAddressMaskAddressPropertyInfo = InetAddressMaskK+    type AttrGetType InetAddressMaskAddressPropertyInfo = InetAddress+    type AttrLabel InetAddressMaskAddressPropertyInfo = "InetAddressMask::address"+    attrGet _ = getInetAddressMaskAddress+    attrSet _ = setInetAddressMaskAddress+    attrConstruct _ = constructInetAddressMaskAddress++-- VVV Prop "family"+   -- Type: TInterface "Gio" "SocketFamily"+   -- Flags: [PropertyReadable]++getInetAddressMaskFamily :: (MonadIO m, InetAddressMaskK o) => o -> m SocketFamily+getInetAddressMaskFamily obj = liftIO $ getObjectPropertyEnum obj "family"++data InetAddressMaskFamilyPropertyInfo+instance AttrInfo InetAddressMaskFamilyPropertyInfo where+    type AttrAllowedOps InetAddressMaskFamilyPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint InetAddressMaskFamilyPropertyInfo = (~) ()+    type AttrBaseTypeConstraint InetAddressMaskFamilyPropertyInfo = InetAddressMaskK+    type AttrGetType InetAddressMaskFamilyPropertyInfo = SocketFamily+    type AttrLabel InetAddressMaskFamilyPropertyInfo = "InetAddressMask::family"+    attrGet _ = getInetAddressMaskFamily+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "length"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getInetAddressMaskLength :: (MonadIO m, InetAddressMaskK o) => o -> m Word32+getInetAddressMaskLength obj = liftIO $ getObjectPropertyCUInt obj "length"++setInetAddressMaskLength :: (MonadIO m, InetAddressMaskK o) => o -> Word32 -> m ()+setInetAddressMaskLength obj val = liftIO $ setObjectPropertyCUInt obj "length" val++constructInetAddressMaskLength :: Word32 -> IO ([Char], GValue)+constructInetAddressMaskLength val = constructObjectPropertyCUInt "length" val++data InetAddressMaskLengthPropertyInfo+instance AttrInfo InetAddressMaskLengthPropertyInfo where+    type AttrAllowedOps InetAddressMaskLengthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint InetAddressMaskLengthPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint InetAddressMaskLengthPropertyInfo = InetAddressMaskK+    type AttrGetType InetAddressMaskLengthPropertyInfo = Word32+    type AttrLabel InetAddressMaskLengthPropertyInfo = "InetAddressMask::length"+    attrGet _ = getInetAddressMaskLength+    attrSet _ = setInetAddressMaskLength+    attrConstruct _ = constructInetAddressMaskLength++type instance AttributeList InetAddressMask = InetAddressMaskAttributeList+type InetAddressMaskAttributeList = ('[ '("address", InetAddressMaskAddressPropertyInfo), '("family", InetAddressMaskFamilyPropertyInfo), '("length", InetAddressMaskLengthPropertyInfo)] :: [(Symbol, *)])++type instance SignalList InetAddressMask = InetAddressMaskSignalList+type InetAddressMaskSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method InetAddressMask::new+-- method type : Constructor+-- Args : [Arg {argName = "addr", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "length", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "addr", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "length", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "InetAddressMask"+-- throws : True+-- Skip return : False++foreign import ccall "g_inet_address_mask_new" g_inet_address_mask_new :: +    Ptr InetAddress ->                      -- addr : TInterface "Gio" "InetAddress"+    Word32 ->                               -- length : TBasicType TUInt32+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr InetAddressMask)+++inetAddressMaskNew ::+    (MonadIO m, InetAddressK a) =>+    a ->                                    -- addr+    Word32 ->                               -- length+    m InetAddressMask+inetAddressMaskNew addr length_ = liftIO $ do+    let addr' = unsafeManagedPtrCastPtr addr+    onException (do+        result <- propagateGError $ g_inet_address_mask_new addr' length_+        checkUnexpectedReturnNULL "g_inet_address_mask_new" result+        result' <- (wrapObject InetAddressMask) result+        touchManagedPtr addr+        return result'+     ) (do+        return ()+     )++-- method InetAddressMask::new_from_string+-- method type : Constructor+-- Args : [Arg {argName = "mask_string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "mask_string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "InetAddressMask"+-- throws : True+-- Skip return : False++foreign import ccall "g_inet_address_mask_new_from_string" g_inet_address_mask_new_from_string :: +    CString ->                              -- mask_string : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr InetAddressMask)+++inetAddressMaskNewFromString ::+    (MonadIO m) =>+    T.Text ->                               -- mask_string+    m InetAddressMask+inetAddressMaskNewFromString mask_string = liftIO $ do+    mask_string' <- textToCString mask_string+    onException (do+        result <- propagateGError $ g_inet_address_mask_new_from_string mask_string'+        checkUnexpectedReturnNULL "g_inet_address_mask_new_from_string" result+        result' <- (wrapObject InetAddressMask) result+        freeMem mask_string'+        return result'+     ) (do+        freeMem mask_string'+     )++-- method InetAddressMask::equal+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddressMask", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mask2", argType = TInterface "Gio" "InetAddressMask", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddressMask", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mask2", argType = TInterface "Gio" "InetAddressMask", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_inet_address_mask_equal" g_inet_address_mask_equal :: +    Ptr InetAddressMask ->                  -- _obj : TInterface "Gio" "InetAddressMask"+    Ptr InetAddressMask ->                  -- mask2 : TInterface "Gio" "InetAddressMask"+    IO CInt+++inetAddressMaskEqual ::+    (MonadIO m, InetAddressMaskK a, InetAddressMaskK b) =>+    a ->                                    -- _obj+    b ->                                    -- mask2+    m Bool+inetAddressMaskEqual _obj mask2 = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let mask2' = unsafeManagedPtrCastPtr mask2+    result <- g_inet_address_mask_equal _obj' mask2'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr mask2+    return result'++-- method InetAddressMask::get_address+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddressMask", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddressMask", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "InetAddress"+-- throws : False+-- Skip return : False++foreign import ccall "g_inet_address_mask_get_address" g_inet_address_mask_get_address :: +    Ptr InetAddressMask ->                  -- _obj : TInterface "Gio" "InetAddressMask"+    IO (Ptr InetAddress)+++inetAddressMaskGetAddress ::+    (MonadIO m, InetAddressMaskK a) =>+    a ->                                    -- _obj+    m InetAddress+inetAddressMaskGetAddress _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_inet_address_mask_get_address _obj'+    checkUnexpectedReturnNULL "g_inet_address_mask_get_address" result+    result' <- (newObject InetAddress) result+    touchManagedPtr _obj+    return result'++-- method InetAddressMask::get_family+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddressMask", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddressMask", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SocketFamily"+-- throws : False+-- Skip return : False++foreign import ccall "g_inet_address_mask_get_family" g_inet_address_mask_get_family :: +    Ptr InetAddressMask ->                  -- _obj : TInterface "Gio" "InetAddressMask"+    IO CUInt+++inetAddressMaskGetFamily ::+    (MonadIO m, InetAddressMaskK a) =>+    a ->                                    -- _obj+    m SocketFamily+inetAddressMaskGetFamily _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_inet_address_mask_get_family _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method InetAddressMask::get_length+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddressMask", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddressMask", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_inet_address_mask_get_length" g_inet_address_mask_get_length :: +    Ptr InetAddressMask ->                  -- _obj : TInterface "Gio" "InetAddressMask"+    IO Word32+++inetAddressMaskGetLength ::+    (MonadIO m, InetAddressMaskK a) =>+    a ->                                    -- _obj+    m Word32+inetAddressMaskGetLength _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_inet_address_mask_get_length _obj'+    touchManagedPtr _obj+    return result++-- method InetAddressMask::matches+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddressMask", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "address", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddressMask", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "address", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_inet_address_mask_matches" g_inet_address_mask_matches :: +    Ptr InetAddressMask ->                  -- _obj : TInterface "Gio" "InetAddressMask"+    Ptr InetAddress ->                      -- address : TInterface "Gio" "InetAddress"+    IO CInt+++inetAddressMaskMatches ::+    (MonadIO m, InetAddressMaskK a, InetAddressK b) =>+    a ->                                    -- _obj+    b ->                                    -- address+    m Bool+inetAddressMaskMatches _obj address = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let address' = unsafeManagedPtrCastPtr address+    result <- g_inet_address_mask_matches _obj' address'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr address+    return result'++-- method InetAddressMask::to_string+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddressMask", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InetAddressMask", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_inet_address_mask_to_string" g_inet_address_mask_to_string :: +    Ptr InetAddressMask ->                  -- _obj : TInterface "Gio" "InetAddressMask"+    IO CString+++inetAddressMaskToString ::+    (MonadIO m, InetAddressMaskK a) =>+    a ->                                    -- _obj+    m T.Text+inetAddressMaskToString _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_inet_address_mask_to_string _obj'+    checkUnexpectedReturnNULL "g_inet_address_mask_to_string" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++
+ GI/Gio/Objects/InetAddressMask.hs-boot view
@@ -0,0 +1,16 @@+module GI.Gio.Objects.InetAddressMask where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype InetAddressMask = InetAddressMask (ForeignPtr InetAddressMask)+instance GObject InetAddressMask where+class GObject o => InetAddressMaskK o+instance (GObject o, IsDescendantOf InetAddressMask o) => InetAddressMaskK o+data InetAddressMaskAddressPropertyInfo+data InetAddressMaskFamilyPropertyInfo+data InetAddressMaskLengthPropertyInfo
+ GI/Gio/Objects/InetSocketAddress.hs view
@@ -0,0 +1,350 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.InetSocketAddress+    ( ++-- * Exported types+    InetSocketAddress(..)                   ,+    InetSocketAddressK                      ,+    toInetSocketAddress                     ,+    noInetSocketAddress                     ,+++ -- * Methods+-- ** inetSocketAddressGetAddress+    inetSocketAddressGetAddress             ,+++-- ** inetSocketAddressGetFlowinfo+    inetSocketAddressGetFlowinfo            ,+++-- ** inetSocketAddressGetPort+    inetSocketAddressGetPort                ,+++-- ** inetSocketAddressGetScopeId+    inetSocketAddressGetScopeId             ,+++-- ** inetSocketAddressNew+    inetSocketAddressNew                    ,+++-- ** inetSocketAddressNewFromString+    inetSocketAddressNewFromString          ,+++++ -- * Properties+-- ** Address+    InetSocketAddressAddressPropertyInfo    ,+    constructInetSocketAddressAddress       ,+    getInetSocketAddressAddress             ,+++-- ** Flowinfo+    InetSocketAddressFlowinfoPropertyInfo   ,+    constructInetSocketAddressFlowinfo      ,+    getInetSocketAddressFlowinfo            ,+++-- ** Port+    InetSocketAddressPortPropertyInfo       ,+    constructInetSocketAddressPort          ,+    getInetSocketAddressPort                ,+++-- ** ScopeId+    InetSocketAddressScopeIdPropertyInfo    ,+    constructInetSocketAddressScopeId       ,+    getInetSocketAddressScopeId             ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype InetSocketAddress = InetSocketAddress (ForeignPtr InetSocketAddress)+foreign import ccall "g_inet_socket_address_get_type"+    c_g_inet_socket_address_get_type :: IO GType++type instance ParentTypes InetSocketAddress = InetSocketAddressParentTypes+type InetSocketAddressParentTypes = '[SocketAddress, GObject.Object, SocketConnectable]++instance GObject InetSocketAddress where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_inet_socket_address_get_type+    ++class GObject o => InetSocketAddressK o+instance (GObject o, IsDescendantOf InetSocketAddress o) => InetSocketAddressK o++toInetSocketAddress :: InetSocketAddressK o => o -> IO InetSocketAddress+toInetSocketAddress = unsafeCastTo InetSocketAddress++noInetSocketAddress :: Maybe InetSocketAddress+noInetSocketAddress = Nothing++-- VVV Prop "address"+   -- Type: TInterface "Gio" "InetAddress"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getInetSocketAddressAddress :: (MonadIO m, InetSocketAddressK o) => o -> m InetAddress+getInetSocketAddressAddress obj = liftIO $ getObjectPropertyObject obj "address" InetAddress++constructInetSocketAddressAddress :: (InetAddressK a) => a -> IO ([Char], GValue)+constructInetSocketAddressAddress val = constructObjectPropertyObject "address" val++data InetSocketAddressAddressPropertyInfo+instance AttrInfo InetSocketAddressAddressPropertyInfo where+    type AttrAllowedOps InetSocketAddressAddressPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint InetSocketAddressAddressPropertyInfo = InetAddressK+    type AttrBaseTypeConstraint InetSocketAddressAddressPropertyInfo = InetSocketAddressK+    type AttrGetType InetSocketAddressAddressPropertyInfo = InetAddress+    type AttrLabel InetSocketAddressAddressPropertyInfo = "InetSocketAddress::address"+    attrGet _ = getInetSocketAddressAddress+    attrSet _ = undefined+    attrConstruct _ = constructInetSocketAddressAddress++-- VVV Prop "flowinfo"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getInetSocketAddressFlowinfo :: (MonadIO m, InetSocketAddressK o) => o -> m Word32+getInetSocketAddressFlowinfo obj = liftIO $ getObjectPropertyCUInt obj "flowinfo"++constructInetSocketAddressFlowinfo :: Word32 -> IO ([Char], GValue)+constructInetSocketAddressFlowinfo val = constructObjectPropertyCUInt "flowinfo" val++data InetSocketAddressFlowinfoPropertyInfo+instance AttrInfo InetSocketAddressFlowinfoPropertyInfo where+    type AttrAllowedOps InetSocketAddressFlowinfoPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint InetSocketAddressFlowinfoPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint InetSocketAddressFlowinfoPropertyInfo = InetSocketAddressK+    type AttrGetType InetSocketAddressFlowinfoPropertyInfo = Word32+    type AttrLabel InetSocketAddressFlowinfoPropertyInfo = "InetSocketAddress::flowinfo"+    attrGet _ = getInetSocketAddressFlowinfo+    attrSet _ = undefined+    attrConstruct _ = constructInetSocketAddressFlowinfo++-- VVV Prop "port"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getInetSocketAddressPort :: (MonadIO m, InetSocketAddressK o) => o -> m Word32+getInetSocketAddressPort obj = liftIO $ getObjectPropertyCUInt obj "port"++constructInetSocketAddressPort :: Word32 -> IO ([Char], GValue)+constructInetSocketAddressPort val = constructObjectPropertyCUInt "port" val++data InetSocketAddressPortPropertyInfo+instance AttrInfo InetSocketAddressPortPropertyInfo where+    type AttrAllowedOps InetSocketAddressPortPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint InetSocketAddressPortPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint InetSocketAddressPortPropertyInfo = InetSocketAddressK+    type AttrGetType InetSocketAddressPortPropertyInfo = Word32+    type AttrLabel InetSocketAddressPortPropertyInfo = "InetSocketAddress::port"+    attrGet _ = getInetSocketAddressPort+    attrSet _ = undefined+    attrConstruct _ = constructInetSocketAddressPort++-- VVV Prop "scope-id"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getInetSocketAddressScopeId :: (MonadIO m, InetSocketAddressK o) => o -> m Word32+getInetSocketAddressScopeId obj = liftIO $ getObjectPropertyCUInt obj "scope-id"++constructInetSocketAddressScopeId :: Word32 -> IO ([Char], GValue)+constructInetSocketAddressScopeId val = constructObjectPropertyCUInt "scope-id" val++data InetSocketAddressScopeIdPropertyInfo+instance AttrInfo InetSocketAddressScopeIdPropertyInfo where+    type AttrAllowedOps InetSocketAddressScopeIdPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint InetSocketAddressScopeIdPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint InetSocketAddressScopeIdPropertyInfo = InetSocketAddressK+    type AttrGetType InetSocketAddressScopeIdPropertyInfo = Word32+    type AttrLabel InetSocketAddressScopeIdPropertyInfo = "InetSocketAddress::scope-id"+    attrGet _ = getInetSocketAddressScopeId+    attrSet _ = undefined+    attrConstruct _ = constructInetSocketAddressScopeId++type instance AttributeList InetSocketAddress = InetSocketAddressAttributeList+type InetSocketAddressAttributeList = ('[ '("address", InetSocketAddressAddressPropertyInfo), '("family", SocketAddressFamilyPropertyInfo), '("flowinfo", InetSocketAddressFlowinfoPropertyInfo), '("port", InetSocketAddressPortPropertyInfo), '("scope-id", InetSocketAddressScopeIdPropertyInfo)] :: [(Symbol, *)])++type instance SignalList InetSocketAddress = InetSocketAddressSignalList+type InetSocketAddressSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method InetSocketAddress::new+-- method type : Constructor+-- Args : [Arg {argName = "address", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "port", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "address", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "port", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "InetSocketAddress"+-- throws : False+-- Skip return : False++foreign import ccall "g_inet_socket_address_new" g_inet_socket_address_new :: +    Ptr InetAddress ->                      -- address : TInterface "Gio" "InetAddress"+    Word16 ->                               -- port : TBasicType TUInt16+    IO (Ptr InetSocketAddress)+++inetSocketAddressNew ::+    (MonadIO m, InetAddressK a) =>+    a ->                                    -- address+    Word16 ->                               -- port+    m InetSocketAddress+inetSocketAddressNew address port = liftIO $ do+    let address' = unsafeManagedPtrCastPtr address+    result <- g_inet_socket_address_new address' port+    checkUnexpectedReturnNULL "g_inet_socket_address_new" result+    result' <- (wrapObject InetSocketAddress) result+    touchManagedPtr address+    return result'++-- method InetSocketAddress::new_from_string+-- method type : Constructor+-- Args : [Arg {argName = "address", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "port", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "address", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "port", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "InetSocketAddress"+-- throws : False+-- Skip return : False++foreign import ccall "g_inet_socket_address_new_from_string" g_inet_socket_address_new_from_string :: +    CString ->                              -- address : TBasicType TUTF8+    Word32 ->                               -- port : TBasicType TUInt32+    IO (Ptr InetSocketAddress)+++inetSocketAddressNewFromString ::+    (MonadIO m) =>+    T.Text ->                               -- address+    Word32 ->                               -- port+    m InetSocketAddress+inetSocketAddressNewFromString address port = liftIO $ do+    address' <- textToCString address+    result <- g_inet_socket_address_new_from_string address' port+    checkUnexpectedReturnNULL "g_inet_socket_address_new_from_string" result+    result' <- (wrapObject InetSocketAddress) result+    freeMem address'+    return result'++-- method InetSocketAddress::get_address+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InetSocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InetSocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "InetAddress"+-- throws : False+-- Skip return : False++foreign import ccall "g_inet_socket_address_get_address" g_inet_socket_address_get_address :: +    Ptr InetSocketAddress ->                -- _obj : TInterface "Gio" "InetSocketAddress"+    IO (Ptr InetAddress)+++inetSocketAddressGetAddress ::+    (MonadIO m, InetSocketAddressK a) =>+    a ->                                    -- _obj+    m InetAddress+inetSocketAddressGetAddress _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_inet_socket_address_get_address _obj'+    checkUnexpectedReturnNULL "g_inet_socket_address_get_address" result+    result' <- (newObject InetAddress) result+    touchManagedPtr _obj+    return result'++-- method InetSocketAddress::get_flowinfo+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InetSocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InetSocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_inet_socket_address_get_flowinfo" g_inet_socket_address_get_flowinfo :: +    Ptr InetSocketAddress ->                -- _obj : TInterface "Gio" "InetSocketAddress"+    IO Word32+++inetSocketAddressGetFlowinfo ::+    (MonadIO m, InetSocketAddressK a) =>+    a ->                                    -- _obj+    m Word32+inetSocketAddressGetFlowinfo _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_inet_socket_address_get_flowinfo _obj'+    touchManagedPtr _obj+    return result++-- method InetSocketAddress::get_port+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InetSocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InetSocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt16+-- throws : False+-- Skip return : False++foreign import ccall "g_inet_socket_address_get_port" g_inet_socket_address_get_port :: +    Ptr InetSocketAddress ->                -- _obj : TInterface "Gio" "InetSocketAddress"+    IO Word16+++inetSocketAddressGetPort ::+    (MonadIO m, InetSocketAddressK a) =>+    a ->                                    -- _obj+    m Word16+inetSocketAddressGetPort _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_inet_socket_address_get_port _obj'+    touchManagedPtr _obj+    return result++-- method InetSocketAddress::get_scope_id+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InetSocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InetSocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_inet_socket_address_get_scope_id" g_inet_socket_address_get_scope_id :: +    Ptr InetSocketAddress ->                -- _obj : TInterface "Gio" "InetSocketAddress"+    IO Word32+++inetSocketAddressGetScopeId ::+    (MonadIO m, InetSocketAddressK a) =>+    a ->                                    -- _obj+    m Word32+inetSocketAddressGetScopeId _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_inet_socket_address_get_scope_id _obj'+    touchManagedPtr _obj+    return result++
+ GI/Gio/Objects/InetSocketAddress.hs-boot view
@@ -0,0 +1,17 @@+module GI.Gio.Objects.InetSocketAddress where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype InetSocketAddress = InetSocketAddress (ForeignPtr InetSocketAddress)+instance GObject InetSocketAddress where+class GObject o => InetSocketAddressK o+instance (GObject o, IsDescendantOf InetSocketAddress o) => InetSocketAddressK o+data InetSocketAddressAddressPropertyInfo+data InetSocketAddressFlowinfoPropertyInfo+data InetSocketAddressPortPropertyInfo+data InetSocketAddressScopeIdPropertyInfo
+ GI/Gio/Objects/InputStream.hs view
@@ -0,0 +1,861 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.InputStream+    ( ++-- * Exported types+    InputStream(..)                         ,+    InputStreamK                            ,+    toInputStream                           ,+    noInputStream                           ,+++ -- * Methods+-- ** inputStreamClearPending+    inputStreamClearPending                 ,+++-- ** inputStreamClose+    inputStreamClose                        ,+++-- ** inputStreamCloseAsync+    inputStreamCloseAsync                   ,+++-- ** inputStreamCloseFinish+    inputStreamCloseFinish                  ,+++-- ** inputStreamHasPending+    inputStreamHasPending                   ,+++-- ** inputStreamIsClosed+    inputStreamIsClosed                     ,+++-- ** inputStreamRead+    inputStreamRead                         ,+++-- ** inputStreamReadAll+    inputStreamReadAll                      ,+++-- ** inputStreamReadAllAsync+    inputStreamReadAllAsync                 ,+++-- ** inputStreamReadAllFinish+    inputStreamReadAllFinish                ,+++-- ** inputStreamReadAsync+    inputStreamReadAsync                    ,+++-- ** inputStreamReadBytes+    inputStreamReadBytes                    ,+++-- ** inputStreamReadBytesAsync+    inputStreamReadBytesAsync               ,+++-- ** inputStreamReadBytesFinish+    inputStreamReadBytesFinish              ,+++-- ** inputStreamReadFinish+    inputStreamReadFinish                   ,+++-- ** inputStreamSetPending+    inputStreamSetPending                   ,+++-- ** inputStreamSkip+    inputStreamSkip                         ,+++-- ** inputStreamSkipAsync+    inputStreamSkipAsync                    ,+++-- ** inputStreamSkipFinish+    inputStreamSkipFinish                   ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype InputStream = InputStream (ForeignPtr InputStream)+foreign import ccall "g_input_stream_get_type"+    c_g_input_stream_get_type :: IO GType++type instance ParentTypes InputStream = InputStreamParentTypes+type InputStreamParentTypes = '[GObject.Object]++instance GObject InputStream where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_input_stream_get_type+    ++class GObject o => InputStreamK o+instance (GObject o, IsDescendantOf InputStream o) => InputStreamK o++toInputStream :: InputStreamK o => o -> IO InputStream+toInputStream = unsafeCastTo InputStream++noInputStream :: Maybe InputStream+noInputStream = Nothing++type instance AttributeList InputStream = InputStreamAttributeList+type InputStreamAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList InputStream = InputStreamSignalList+type InputStreamSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method InputStream::clear_pending+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_input_stream_clear_pending" g_input_stream_clear_pending :: +    Ptr InputStream ->                      -- _obj : TInterface "Gio" "InputStream"+    IO ()+++inputStreamClearPending ::+    (MonadIO m, InputStreamK a) =>+    a ->                                    -- _obj+    m ()+inputStreamClearPending _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_input_stream_clear_pending _obj'+    touchManagedPtr _obj+    return ()++-- method InputStream::close+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_input_stream_close" g_input_stream_close :: +    Ptr InputStream ->                      -- _obj : TInterface "Gio" "InputStream"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++inputStreamClose ::+    (MonadIO m, InputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m ()+inputStreamClose _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_input_stream_close _obj' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method InputStream::close_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_input_stream_close_async" g_input_stream_close_async :: +    Ptr InputStream ->                      -- _obj : TInterface "Gio" "InputStream"+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++inputStreamCloseAsync ::+    (MonadIO m, InputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+inputStreamCloseAsync _obj io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_input_stream_close_async _obj' io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method InputStream::close_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_input_stream_close_finish" g_input_stream_close_finish :: +    Ptr InputStream ->                      -- _obj : TInterface "Gio" "InputStream"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++inputStreamCloseFinish ::+    (MonadIO m, InputStreamK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+inputStreamCloseFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_input_stream_close_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++-- method InputStream::has_pending+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_input_stream_has_pending" g_input_stream_has_pending :: +    Ptr InputStream ->                      -- _obj : TInterface "Gio" "InputStream"+    IO CInt+++inputStreamHasPending ::+    (MonadIO m, InputStreamK a) =>+    a ->                                    -- _obj+    m Bool+inputStreamHasPending _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_input_stream_has_pending _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method InputStream::is_closed+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_input_stream_is_closed" g_input_stream_is_closed :: +    Ptr InputStream ->                      -- _obj : TInterface "Gio" "InputStream"+    IO CInt+++inputStreamIsClosed ::+    (MonadIO m, InputStreamK a) =>+    a ->                                    -- _obj+    m Bool+inputStreamIsClosed _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_input_stream_is_closed _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method InputStream::read+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : True+-- Skip return : False++foreign import ccall "g_input_stream_read" g_input_stream_read :: +    Ptr InputStream ->                      -- _obj : TInterface "Gio" "InputStream"+    Ptr Word8 ->                            -- buffer : TCArray False (-1) 2 (TBasicType TUInt8)+    Word64 ->                               -- count : TBasicType TUInt64+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO Int64+++inputStreamRead ::+    (MonadIO m, InputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    ByteString ->                           -- buffer+    Maybe (b) ->                            -- cancellable+    m Int64+inputStreamRead _obj buffer cancellable = liftIO $ do+    let count = fromIntegral $ B.length buffer+    let _obj' = unsafeManagedPtrCastPtr _obj+    buffer' <- packByteString buffer+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_input_stream_read _obj' buffer' count maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem buffer'+        return result+     ) (do+        freeMem buffer'+     )++-- method InputStream::read_all+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "bytes_read", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_input_stream_read_all" g_input_stream_read_all :: +    Ptr InputStream ->                      -- _obj : TInterface "Gio" "InputStream"+    Ptr Word8 ->                            -- buffer : TCArray False (-1) 2 (TBasicType TUInt8)+    Word64 ->                               -- count : TBasicType TUInt64+    Ptr Word64 ->                           -- bytes_read : TBasicType TUInt64+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++inputStreamReadAll ::+    (MonadIO m, InputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    ByteString ->                           -- buffer+    Maybe (b) ->                            -- cancellable+    m (Word64)+inputStreamReadAll _obj buffer cancellable = liftIO $ do+    let count = fromIntegral $ B.length buffer+    let _obj' = unsafeManagedPtrCastPtr _obj+    buffer' <- packByteString buffer+    bytes_read <- allocMem :: IO (Ptr Word64)+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_input_stream_read_all _obj' buffer' count bytes_read maybeCancellable+        bytes_read' <- peek bytes_read+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem buffer'+        freeMem bytes_read+        return bytes_read'+     ) (do+        freeMem buffer'+        freeMem bytes_read+     )++-- method InputStream::read_all_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_input_stream_read_all_async" g_input_stream_read_all_async :: +    Ptr InputStream ->                      -- _obj : TInterface "Gio" "InputStream"+    Ptr Word8 ->                            -- buffer : TCArray False (-1) 2 (TBasicType TUInt8)+    Word64 ->                               -- count : TBasicType TUInt64+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++inputStreamReadAllAsync ::+    (MonadIO m, InputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    ByteString ->                           -- buffer+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+inputStreamReadAllAsync _obj buffer io_priority cancellable callback = liftIO $ do+    let count = fromIntegral $ B.length buffer+    let _obj' = unsafeManagedPtrCastPtr _obj+    buffer' <- packByteString buffer+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_input_stream_read_all_async _obj' buffer' count io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    freeMem buffer'+    return ()++-- method InputStream::read_all_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "bytes_read", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_input_stream_read_all_finish" g_input_stream_read_all_finish :: +    Ptr InputStream ->                      -- _obj : TInterface "Gio" "InputStream"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr Word64 ->                           -- bytes_read : TBasicType TUInt64+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++inputStreamReadAllFinish ::+    (MonadIO m, InputStreamK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m (Word64)+inputStreamReadAllFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    bytes_read <- allocMem :: IO (Ptr Word64)+    onException (do+        _ <- propagateGError $ g_input_stream_read_all_finish _obj' result_' bytes_read+        bytes_read' <- peek bytes_read+        touchManagedPtr _obj+        touchManagedPtr result_+        freeMem bytes_read+        return bytes_read'+     ) (do+        freeMem bytes_read+     )++-- method InputStream::read_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_input_stream_read_async" g_input_stream_read_async :: +    Ptr InputStream ->                      -- _obj : TInterface "Gio" "InputStream"+    Ptr Word8 ->                            -- buffer : TCArray False (-1) 2 (TBasicType TUInt8)+    Word64 ->                               -- count : TBasicType TUInt64+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++inputStreamReadAsync ::+    (MonadIO m, InputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    ByteString ->                           -- buffer+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+inputStreamReadAsync _obj buffer io_priority cancellable callback = liftIO $ do+    let count = fromIntegral $ B.length buffer+    let _obj' = unsafeManagedPtrCastPtr _obj+    buffer' <- packByteString buffer+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_input_stream_read_async _obj' buffer' count io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    freeMem buffer'+    return ()++-- method InputStream::read_bytes+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GLib" "Bytes"+-- throws : True+-- Skip return : False++foreign import ccall "g_input_stream_read_bytes" g_input_stream_read_bytes :: +    Ptr InputStream ->                      -- _obj : TInterface "Gio" "InputStream"+    Word64 ->                               -- count : TBasicType TUInt64+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr GLib.Bytes)+++inputStreamReadBytes ::+    (MonadIO m, InputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Word64 ->                               -- count+    Maybe (b) ->                            -- cancellable+    m GLib.Bytes+inputStreamReadBytes _obj count cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_input_stream_read_bytes _obj' count maybeCancellable+        checkUnexpectedReturnNULL "g_input_stream_read_bytes" result+        result' <- (wrapBoxed GLib.Bytes) result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )++-- method InputStream::read_bytes_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_input_stream_read_bytes_async" g_input_stream_read_bytes_async :: +    Ptr InputStream ->                      -- _obj : TInterface "Gio" "InputStream"+    Word64 ->                               -- count : TBasicType TUInt64+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++inputStreamReadBytesAsync ::+    (MonadIO m, InputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Word64 ->                               -- count+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+inputStreamReadBytesAsync _obj count io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_input_stream_read_bytes_async _obj' count io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method InputStream::read_bytes_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GLib" "Bytes"+-- throws : True+-- Skip return : False++foreign import ccall "g_input_stream_read_bytes_finish" g_input_stream_read_bytes_finish :: +    Ptr InputStream ->                      -- _obj : TInterface "Gio" "InputStream"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr GLib.Bytes)+++inputStreamReadBytesFinish ::+    (MonadIO m, InputStreamK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m GLib.Bytes+inputStreamReadBytesFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        result <- propagateGError $ g_input_stream_read_bytes_finish _obj' result_'+        checkUnexpectedReturnNULL "g_input_stream_read_bytes_finish" result+        result' <- (wrapBoxed GLib.Bytes) result+        touchManagedPtr _obj+        touchManagedPtr result_+        return result'+     ) (do+        return ()+     )++-- method InputStream::read_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : True+-- Skip return : False++foreign import ccall "g_input_stream_read_finish" g_input_stream_read_finish :: +    Ptr InputStream ->                      -- _obj : TInterface "Gio" "InputStream"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO Int64+++inputStreamReadFinish ::+    (MonadIO m, InputStreamK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m Int64+inputStreamReadFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        result <- propagateGError $ g_input_stream_read_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return result+     ) (do+        return ()+     )++-- method InputStream::set_pending+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_input_stream_set_pending" g_input_stream_set_pending :: +    Ptr InputStream ->                      -- _obj : TInterface "Gio" "InputStream"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++inputStreamSetPending ::+    (MonadIO m, InputStreamK a) =>+    a ->                                    -- _obj+    m ()+inputStreamSetPending _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    onException (do+        _ <- propagateGError $ g_input_stream_set_pending _obj'+        touchManagedPtr _obj+        return ()+     ) (do+        return ()+     )++-- method InputStream::skip+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : True+-- Skip return : False++foreign import ccall "g_input_stream_skip" g_input_stream_skip :: +    Ptr InputStream ->                      -- _obj : TInterface "Gio" "InputStream"+    Word64 ->                               -- count : TBasicType TUInt64+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO Int64+++inputStreamSkip ::+    (MonadIO m, InputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Word64 ->                               -- count+    Maybe (b) ->                            -- cancellable+    m Int64+inputStreamSkip _obj count cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_input_stream_skip _obj' count maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return result+     ) (do+        return ()+     )++-- method InputStream::skip_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_input_stream_skip_async" g_input_stream_skip_async :: +    Ptr InputStream ->                      -- _obj : TInterface "Gio" "InputStream"+    Word64 ->                               -- count : TBasicType TUInt64+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++inputStreamSkipAsync ::+    (MonadIO m, InputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Word64 ->                               -- count+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+inputStreamSkipAsync _obj count io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_input_stream_skip_async _obj' count io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method InputStream::skip_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : True+-- Skip return : False++foreign import ccall "g_input_stream_skip_finish" g_input_stream_skip_finish :: +    Ptr InputStream ->                      -- _obj : TInterface "Gio" "InputStream"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO Int64+++inputStreamSkipFinish ::+    (MonadIO m, InputStreamK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m Int64+inputStreamSkipFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        result <- propagateGError $ g_input_stream_skip_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return result+     ) (do+        return ()+     )++
+ GI/Gio/Objects/InputStream.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Objects.InputStream where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype InputStream = InputStream (ForeignPtr InputStream)+instance GObject InputStream where+class GObject o => InputStreamK o+instance (GObject o, IsDescendantOf InputStream o) => InputStreamK o
+ GI/Gio/Objects/ListStore.hs view
@@ -0,0 +1,357 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.ListStore+    ( ++-- * Exported types+    ListStore(..)                           ,+    ListStoreK                              ,+    toListStore                             ,+    noListStore                             ,+++ -- * Methods+-- ** listStoreAppend+    listStoreAppend                         ,+++-- ** listStoreInsert+    listStoreInsert                         ,+++-- ** listStoreInsertSorted+    listStoreInsertSorted                   ,+++-- ** listStoreNew+    listStoreNew                            ,+++-- ** listStoreRemove+    listStoreRemove                         ,+++-- ** listStoreRemoveAll+    listStoreRemoveAll                      ,+++-- ** listStoreSort+    listStoreSort                           ,+++-- ** listStoreSplice+    listStoreSplice                         ,+++++ -- * Properties+-- ** ItemType+    ListStoreItemTypePropertyInfo           ,+    constructListStoreItemType              ,+    getListStoreItemType                    ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype ListStore = ListStore (ForeignPtr ListStore)+foreign import ccall "g_list_store_get_type"+    c_g_list_store_get_type :: IO GType++type instance ParentTypes ListStore = ListStoreParentTypes+type ListStoreParentTypes = '[GObject.Object, ListModel]++instance GObject ListStore where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_list_store_get_type+    ++class GObject o => ListStoreK o+instance (GObject o, IsDescendantOf ListStore o) => ListStoreK o++toListStore :: ListStoreK o => o -> IO ListStore+toListStore = unsafeCastTo ListStore++noListStore :: Maybe ListStore+noListStore = Nothing++-- VVV Prop "item-type"+   -- Type: TBasicType TGType+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getListStoreItemType :: (MonadIO m, ListStoreK o) => o -> m GType+getListStoreItemType obj = liftIO $ getObjectPropertyGType obj "item-type"++constructListStoreItemType :: GType -> IO ([Char], GValue)+constructListStoreItemType val = constructObjectPropertyGType "item-type" val++data ListStoreItemTypePropertyInfo+instance AttrInfo ListStoreItemTypePropertyInfo where+    type AttrAllowedOps ListStoreItemTypePropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ListStoreItemTypePropertyInfo = (~) GType+    type AttrBaseTypeConstraint ListStoreItemTypePropertyInfo = ListStoreK+    type AttrGetType ListStoreItemTypePropertyInfo = GType+    type AttrLabel ListStoreItemTypePropertyInfo = "ListStore::item-type"+    attrGet _ = getListStoreItemType+    attrSet _ = undefined+    attrConstruct _ = constructListStoreItemType++type instance AttributeList ListStore = ListStoreAttributeList+type ListStoreAttributeList = ('[ '("item-type", ListStoreItemTypePropertyInfo)] :: [(Symbol, *)])++type instance SignalList ListStore = ListStoreSignalList+type ListStoreSignalList = ('[ '("items-changed", ListModelItemsChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method ListStore::new+-- method type : Constructor+-- Args : [Arg {argName = "item_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "item_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "ListStore"+-- throws : False+-- Skip return : False++foreign import ccall "g_list_store_new" g_list_store_new :: +    CGType ->                               -- item_type : TBasicType TGType+    IO (Ptr ListStore)+++listStoreNew ::+    (MonadIO m) =>+    GType ->                                -- item_type+    m ListStore+listStoreNew item_type = liftIO $ do+    let item_type' = gtypeToCGType item_type+    result <- g_list_store_new item_type'+    checkUnexpectedReturnNULL "g_list_store_new" result+    result' <- (wrapObject ListStore) result+    return result'++-- method ListStore::append+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "item", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "item", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_list_store_append" g_list_store_append :: +    Ptr ListStore ->                        -- _obj : TInterface "Gio" "ListStore"+    Ptr GObject.Object ->                   -- item : TInterface "GObject" "Object"+    IO ()+++listStoreAppend ::+    (MonadIO m, ListStoreK a, GObject.ObjectK b) =>+    a ->                                    -- _obj+    b ->                                    -- item+    m ()+listStoreAppend _obj item = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let item' = unsafeManagedPtrCastPtr item+    g_list_store_append _obj' item'+    touchManagedPtr _obj+    touchManagedPtr item+    return ()++-- method ListStore::insert+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "item", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "item", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_list_store_insert" g_list_store_insert :: +    Ptr ListStore ->                        -- _obj : TInterface "Gio" "ListStore"+    Word32 ->                               -- position : TBasicType TUInt32+    Ptr GObject.Object ->                   -- item : TInterface "GObject" "Object"+    IO ()+++listStoreInsert ::+    (MonadIO m, ListStoreK a, GObject.ObjectK b) =>+    a ->                                    -- _obj+    Word32 ->                               -- position+    b ->                                    -- item+    m ()+listStoreInsert _obj position item = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let item' = unsafeManagedPtrCastPtr item+    g_list_store_insert _obj' position item'+    touchManagedPtr _obj+    touchManagedPtr item+    return ()++-- method ListStore::insert_sorted+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "item", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "compare_func", argType = TInterface "GLib" "CompareDataFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 3, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "item", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "compare_func", argType = TInterface "GLib" "CompareDataFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 3, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_list_store_insert_sorted" g_list_store_insert_sorted :: +    Ptr ListStore ->                        -- _obj : TInterface "Gio" "ListStore"+    Ptr GObject.Object ->                   -- item : TInterface "GObject" "Object"+    FunPtr GLib.CompareDataFuncC ->         -- compare_func : TInterface "GLib" "CompareDataFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO Word32+++listStoreInsertSorted ::+    (MonadIO m, ListStoreK a, GObject.ObjectK b) =>+    a ->                                    -- _obj+    b ->                                    -- item+    GLib.CompareDataFunc ->                 -- compare_func+    m Word32+listStoreInsertSorted _obj item compare_func = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let item' = unsafeManagedPtrCastPtr item+    compare_func' <- GLib.mkCompareDataFunc (GLib.compareDataFuncWrapper Nothing compare_func)+    let user_data = nullPtr+    result <- g_list_store_insert_sorted _obj' item' compare_func' user_data+    safeFreeFunPtr $ castFunPtrToPtr compare_func'+    touchManagedPtr _obj+    touchManagedPtr item+    return result++-- method ListStore::remove+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_list_store_remove" g_list_store_remove :: +    Ptr ListStore ->                        -- _obj : TInterface "Gio" "ListStore"+    Word32 ->                               -- position : TBasicType TUInt32+    IO ()+++listStoreRemove ::+    (MonadIO m, ListStoreK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- position+    m ()+listStoreRemove _obj position = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_list_store_remove _obj' position+    touchManagedPtr _obj+    return ()++-- method ListStore::remove_all+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_list_store_remove_all" g_list_store_remove_all :: +    Ptr ListStore ->                        -- _obj : TInterface "Gio" "ListStore"+    IO ()+++listStoreRemoveAll ::+    (MonadIO m, ListStoreK a) =>+    a ->                                    -- _obj+    m ()+listStoreRemoveAll _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_list_store_remove_all _obj'+    touchManagedPtr _obj+    return ()++-- method ListStore::sort+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "compare_func", argType = TInterface "GLib" "CompareDataFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "compare_func", argType = TInterface "GLib" "CompareDataFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_list_store_sort" g_list_store_sort :: +    Ptr ListStore ->                        -- _obj : TInterface "Gio" "ListStore"+    FunPtr GLib.CompareDataFuncC ->         -- compare_func : TInterface "GLib" "CompareDataFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++listStoreSort ::+    (MonadIO m, ListStoreK a) =>+    a ->                                    -- _obj+    GLib.CompareDataFunc ->                 -- compare_func+    m ()+listStoreSort _obj compare_func = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    compare_func' <- GLib.mkCompareDataFunc (GLib.compareDataFuncWrapper Nothing compare_func)+    let user_data = nullPtr+    g_list_store_sort _obj' compare_func' user_data+    safeFreeFunPtr $ castFunPtrToPtr compare_func'+    touchManagedPtr _obj+    return ()++-- method ListStore::splice+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_removals", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "additions", argType = TCArray False (-1) 4 (TInterface "GObject" "Object"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_additions", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "n_additions", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_removals", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "additions", argType = TCArray False (-1) 4 (TInterface "GObject" "Object"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_list_store_splice" g_list_store_splice :: +    Ptr ListStore ->                        -- _obj : TInterface "Gio" "ListStore"+    Word32 ->                               -- position : TBasicType TUInt32+    Word32 ->                               -- n_removals : TBasicType TUInt32+    Ptr (Ptr GObject.Object) ->             -- additions : TCArray False (-1) 4 (TInterface "GObject" "Object")+    Word32 ->                               -- n_additions : TBasicType TUInt32+    IO ()+++listStoreSplice ::+    (MonadIO m, ListStoreK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- position+    Word32 ->                               -- n_removals+    [GObject.Object] ->                     -- additions+    m ()+listStoreSplice _obj position n_removals additions = liftIO $ do+    let n_additions = fromIntegral $ length additions+    let _obj' = unsafeManagedPtrCastPtr _obj+    let additions' = map unsafeManagedPtrCastPtr additions+    additions'' <- packPtrArray additions'+    g_list_store_splice _obj' position n_removals additions'' n_additions+    touchManagedPtr _obj+    mapM_ touchManagedPtr additions+    freeMem additions''+    return ()++
+ GI/Gio/Objects/ListStore.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gio.Objects.ListStore where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype ListStore = ListStore (ForeignPtr ListStore)+instance GObject ListStore where+class GObject o => ListStoreK o+instance (GObject o, IsDescendantOf ListStore o) => ListStoreK o+data ListStoreItemTypePropertyInfo
+ GI/Gio/Objects/MemoryInputStream.hs view
@@ -0,0 +1,232 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.MemoryInputStream+    ( ++-- * Exported types+    MemoryInputStream(..)                   ,+    MemoryInputStreamK                      ,+    toMemoryInputStream                     ,+    noMemoryInputStream                     ,+++ -- * Methods+-- ** memoryInputStreamAddBytes+    memoryInputStreamAddBytes               ,+++-- ** memoryInputStreamAddData+    memoryInputStreamAddData                ,+++-- ** memoryInputStreamNew+    memoryInputStreamNew                    ,+++-- ** memoryInputStreamNewFromBytes+    memoryInputStreamNewFromBytes           ,+++-- ** memoryInputStreamNewFromData+    memoryInputStreamNewFromData            ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype MemoryInputStream = MemoryInputStream (ForeignPtr MemoryInputStream)+foreign import ccall "g_memory_input_stream_get_type"+    c_g_memory_input_stream_get_type :: IO GType++type instance ParentTypes MemoryInputStream = MemoryInputStreamParentTypes+type MemoryInputStreamParentTypes = '[InputStream, GObject.Object, PollableInputStream, Seekable]++instance GObject MemoryInputStream where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_memory_input_stream_get_type+    ++class GObject o => MemoryInputStreamK o+instance (GObject o, IsDescendantOf MemoryInputStream o) => MemoryInputStreamK o++toMemoryInputStream :: MemoryInputStreamK o => o -> IO MemoryInputStream+toMemoryInputStream = unsafeCastTo MemoryInputStream++noMemoryInputStream :: Maybe MemoryInputStream+noMemoryInputStream = Nothing++type instance AttributeList MemoryInputStream = MemoryInputStreamAttributeList+type MemoryInputStreamAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList MemoryInputStream = MemoryInputStreamSignalList+type MemoryInputStreamSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method MemoryInputStream::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gio" "MemoryInputStream"+-- throws : False+-- Skip return : False++foreign import ccall "g_memory_input_stream_new" g_memory_input_stream_new :: +    IO (Ptr MemoryInputStream)+++memoryInputStreamNew ::+    (MonadIO m) =>+    m MemoryInputStream+memoryInputStreamNew  = liftIO $ do+    result <- g_memory_input_stream_new+    checkUnexpectedReturnNULL "g_memory_input_stream_new" result+    result' <- (wrapObject MemoryInputStream) result+    return result'++-- method MemoryInputStream::new_from_bytes+-- method type : Constructor+-- Args : [Arg {argName = "bytes", argType = TInterface "GLib" "Bytes", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "bytes", argType = TInterface "GLib" "Bytes", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "MemoryInputStream"+-- throws : False+-- Skip return : False++foreign import ccall "g_memory_input_stream_new_from_bytes" g_memory_input_stream_new_from_bytes :: +    Ptr GLib.Bytes ->                       -- bytes : TInterface "GLib" "Bytes"+    IO (Ptr MemoryInputStream)+++memoryInputStreamNewFromBytes ::+    (MonadIO m) =>+    GLib.Bytes ->                           -- bytes+    m MemoryInputStream+memoryInputStreamNewFromBytes bytes = liftIO $ do+    let bytes' = unsafeManagedPtrGetPtr bytes+    result <- g_memory_input_stream_new_from_bytes bytes'+    checkUnexpectedReturnNULL "g_memory_input_stream_new_from_bytes" result+    result' <- (wrapObject MemoryInputStream) result+    touchManagedPtr bytes+    return result'++-- method MemoryInputStream::new_from_data+-- method type : Constructor+-- Args : [Arg {argName = "data", argType = TCArray False (-1) 1 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "len", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "destroy", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "len", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "data", argType = TCArray False (-1) 1 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "destroy", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "MemoryInputStream"+-- throws : False+-- Skip return : False++foreign import ccall "g_memory_input_stream_new_from_data" g_memory_input_stream_new_from_data :: +    Ptr Word8 ->                            -- data : TCArray False (-1) 1 (TBasicType TUInt8)+    Int64 ->                                -- len : TBasicType TInt64+    FunPtr GLib.DestroyNotifyC ->           -- destroy : TInterface "GLib" "DestroyNotify"+    IO (Ptr MemoryInputStream)+++memoryInputStreamNewFromData ::+    (MonadIO m) =>+    ByteString ->                           -- data+    Maybe (GLib.DestroyNotify) ->           -- destroy+    m MemoryInputStream+memoryInputStreamNewFromData data_ destroy = liftIO $ do+    let len = fromIntegral $ B.length data_+    data_' <- packByteString data_+    ptrdestroy <- callocMem :: IO (Ptr (FunPtr GLib.DestroyNotifyC))+    maybeDestroy <- case destroy of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jDestroy -> do+            jDestroy' <- GLib.mkDestroyNotify (GLib.destroyNotifyWrapper (Just ptrdestroy) jDestroy)+            poke ptrdestroy jDestroy'+            return jDestroy'+    result <- g_memory_input_stream_new_from_data data_' len maybeDestroy+    checkUnexpectedReturnNULL "g_memory_input_stream_new_from_data" result+    result' <- (wrapObject MemoryInputStream) result+    return result'++-- method MemoryInputStream::add_bytes+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MemoryInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "bytes", argType = TInterface "GLib" "Bytes", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MemoryInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "bytes", argType = TInterface "GLib" "Bytes", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_memory_input_stream_add_bytes" g_memory_input_stream_add_bytes :: +    Ptr MemoryInputStream ->                -- _obj : TInterface "Gio" "MemoryInputStream"+    Ptr GLib.Bytes ->                       -- bytes : TInterface "GLib" "Bytes"+    IO ()+++memoryInputStreamAddBytes ::+    (MonadIO m, MemoryInputStreamK a) =>+    a ->                                    -- _obj+    GLib.Bytes ->                           -- bytes+    m ()+memoryInputStreamAddBytes _obj bytes = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let bytes' = unsafeManagedPtrGetPtr bytes+    g_memory_input_stream_add_bytes _obj' bytes'+    touchManagedPtr _obj+    touchManagedPtr bytes+    return ()++-- method MemoryInputStream::add_data+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MemoryInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "data", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "len", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "destroy", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "len", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MemoryInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "data", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "destroy", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_memory_input_stream_add_data" g_memory_input_stream_add_data :: +    Ptr MemoryInputStream ->                -- _obj : TInterface "Gio" "MemoryInputStream"+    Ptr Word8 ->                            -- data : TCArray False (-1) 2 (TBasicType TUInt8)+    Int64 ->                                -- len : TBasicType TInt64+    FunPtr GLib.DestroyNotifyC ->           -- destroy : TInterface "GLib" "DestroyNotify"+    IO ()+++memoryInputStreamAddData ::+    (MonadIO m, MemoryInputStreamK a) =>+    a ->                                    -- _obj+    ByteString ->                           -- data+    Maybe (GLib.DestroyNotify) ->           -- destroy+    m ()+memoryInputStreamAddData _obj data_ destroy = liftIO $ do+    let len = fromIntegral $ B.length data_+    let _obj' = unsafeManagedPtrCastPtr _obj+    data_' <- packByteString data_+    ptrdestroy <- callocMem :: IO (Ptr (FunPtr GLib.DestroyNotifyC))+    maybeDestroy <- case destroy of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jDestroy -> do+            jDestroy' <- GLib.mkDestroyNotify (GLib.destroyNotifyWrapper (Just ptrdestroy) jDestroy)+            poke ptrdestroy jDestroy'+            return jDestroy'+    g_memory_input_stream_add_data _obj' data_' len maybeDestroy+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Objects/MemoryInputStream.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Objects.MemoryInputStream where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype MemoryInputStream = MemoryInputStream (ForeignPtr MemoryInputStream)+instance GObject MemoryInputStream where+class GObject o => MemoryInputStreamK o+instance (GObject o, IsDescendantOf MemoryInputStream o) => MemoryInputStreamK o
+ GI/Gio/Objects/MemoryOutputStream.hs view
@@ -0,0 +1,310 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.MemoryOutputStream+    ( ++-- * Exported types+    MemoryOutputStream(..)                  ,+    MemoryOutputStreamK                     ,+    toMemoryOutputStream                    ,+    noMemoryOutputStream                    ,+++ -- * Methods+-- ** memoryOutputStreamGetData+    memoryOutputStreamGetData               ,+++-- ** memoryOutputStreamGetDataSize+    memoryOutputStreamGetDataSize           ,+++-- ** memoryOutputStreamGetSize+    memoryOutputStreamGetSize               ,+++-- ** memoryOutputStreamNewResizable+    memoryOutputStreamNewResizable          ,+++-- ** memoryOutputStreamStealAsBytes+    memoryOutputStreamStealAsBytes          ,+++-- ** memoryOutputStreamStealData+    memoryOutputStreamStealData             ,+++++ -- * Properties+-- ** Data+    MemoryOutputStreamDataPropertyInfo      ,+    constructMemoryOutputStreamData         ,+    getMemoryOutputStreamData               ,+++-- ** DataSize+    MemoryOutputStreamDataSizePropertyInfo  ,+    getMemoryOutputStreamDataSize           ,+++-- ** Size+    MemoryOutputStreamSizePropertyInfo      ,+    constructMemoryOutputStreamSize         ,+    getMemoryOutputStreamSize               ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype MemoryOutputStream = MemoryOutputStream (ForeignPtr MemoryOutputStream)+foreign import ccall "g_memory_output_stream_get_type"+    c_g_memory_output_stream_get_type :: IO GType++type instance ParentTypes MemoryOutputStream = MemoryOutputStreamParentTypes+type MemoryOutputStreamParentTypes = '[OutputStream, GObject.Object, PollableOutputStream, Seekable]++instance GObject MemoryOutputStream where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_memory_output_stream_get_type+    ++class GObject o => MemoryOutputStreamK o+instance (GObject o, IsDescendantOf MemoryOutputStream o) => MemoryOutputStreamK o++toMemoryOutputStream :: MemoryOutputStreamK o => o -> IO MemoryOutputStream+toMemoryOutputStream = unsafeCastTo MemoryOutputStream++noMemoryOutputStream :: Maybe MemoryOutputStream+noMemoryOutputStream = Nothing++-- VVV Prop "data"+   -- Type: TBasicType TVoid+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getMemoryOutputStreamData :: (MonadIO m, MemoryOutputStreamK o) => o -> m (Ptr ())+getMemoryOutputStreamData obj = liftIO $ getObjectPropertyPtr obj "data"++constructMemoryOutputStreamData :: (Ptr ()) -> IO ([Char], GValue)+constructMemoryOutputStreamData val = constructObjectPropertyPtr "data" val++data MemoryOutputStreamDataPropertyInfo+instance AttrInfo MemoryOutputStreamDataPropertyInfo where+    type AttrAllowedOps MemoryOutputStreamDataPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MemoryOutputStreamDataPropertyInfo = (~) (Ptr ())+    type AttrBaseTypeConstraint MemoryOutputStreamDataPropertyInfo = MemoryOutputStreamK+    type AttrGetType MemoryOutputStreamDataPropertyInfo = (Ptr ())+    type AttrLabel MemoryOutputStreamDataPropertyInfo = "MemoryOutputStream::data"+    attrGet _ = getMemoryOutputStreamData+    attrSet _ = undefined+    attrConstruct _ = constructMemoryOutputStreamData++-- VVV Prop "data-size"+   -- Type: TBasicType TUInt64+   -- Flags: [PropertyReadable]++getMemoryOutputStreamDataSize :: (MonadIO m, MemoryOutputStreamK o) => o -> m Word64+getMemoryOutputStreamDataSize obj = liftIO $ getObjectPropertyUInt64 obj "data-size"++data MemoryOutputStreamDataSizePropertyInfo+instance AttrInfo MemoryOutputStreamDataSizePropertyInfo where+    type AttrAllowedOps MemoryOutputStreamDataSizePropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint MemoryOutputStreamDataSizePropertyInfo = (~) ()+    type AttrBaseTypeConstraint MemoryOutputStreamDataSizePropertyInfo = MemoryOutputStreamK+    type AttrGetType MemoryOutputStreamDataSizePropertyInfo = Word64+    type AttrLabel MemoryOutputStreamDataSizePropertyInfo = "MemoryOutputStream::data-size"+    attrGet _ = getMemoryOutputStreamDataSize+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "size"+   -- Type: TBasicType TUInt64+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getMemoryOutputStreamSize :: (MonadIO m, MemoryOutputStreamK o) => o -> m Word64+getMemoryOutputStreamSize obj = liftIO $ getObjectPropertyUInt64 obj "size"++constructMemoryOutputStreamSize :: Word64 -> IO ([Char], GValue)+constructMemoryOutputStreamSize val = constructObjectPropertyUInt64 "size" val++data MemoryOutputStreamSizePropertyInfo+instance AttrInfo MemoryOutputStreamSizePropertyInfo where+    type AttrAllowedOps MemoryOutputStreamSizePropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MemoryOutputStreamSizePropertyInfo = (~) Word64+    type AttrBaseTypeConstraint MemoryOutputStreamSizePropertyInfo = MemoryOutputStreamK+    type AttrGetType MemoryOutputStreamSizePropertyInfo = Word64+    type AttrLabel MemoryOutputStreamSizePropertyInfo = "MemoryOutputStream::size"+    attrGet _ = getMemoryOutputStreamSize+    attrSet _ = undefined+    attrConstruct _ = constructMemoryOutputStreamSize++type instance AttributeList MemoryOutputStream = MemoryOutputStreamAttributeList+type MemoryOutputStreamAttributeList = ('[ '("data", MemoryOutputStreamDataPropertyInfo), '("data-size", MemoryOutputStreamDataSizePropertyInfo), '("size", MemoryOutputStreamSizePropertyInfo)] :: [(Symbol, *)])++type instance SignalList MemoryOutputStream = MemoryOutputStreamSignalList+type MemoryOutputStreamSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method MemoryOutputStream::new_resizable+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gio" "MemoryOutputStream"+-- throws : False+-- Skip return : False++foreign import ccall "g_memory_output_stream_new_resizable" g_memory_output_stream_new_resizable :: +    IO (Ptr MemoryOutputStream)+++memoryOutputStreamNewResizable ::+    (MonadIO m) =>+    m MemoryOutputStream+memoryOutputStreamNewResizable  = liftIO $ do+    result <- g_memory_output_stream_new_resizable+    checkUnexpectedReturnNULL "g_memory_output_stream_new_resizable" result+    result' <- (wrapObject MemoryOutputStream) result+    return result'++-- method MemoryOutputStream::get_data+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MemoryOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MemoryOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_memory_output_stream_get_data" g_memory_output_stream_get_data :: +    Ptr MemoryOutputStream ->               -- _obj : TInterface "Gio" "MemoryOutputStream"+    IO ()+++memoryOutputStreamGetData ::+    (MonadIO m, MemoryOutputStreamK a) =>+    a ->                                    -- _obj+    m ()+memoryOutputStreamGetData _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_memory_output_stream_get_data _obj'+    touchManagedPtr _obj+    return ()++-- method MemoryOutputStream::get_data_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MemoryOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MemoryOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "g_memory_output_stream_get_data_size" g_memory_output_stream_get_data_size :: +    Ptr MemoryOutputStream ->               -- _obj : TInterface "Gio" "MemoryOutputStream"+    IO Word64+++memoryOutputStreamGetDataSize ::+    (MonadIO m, MemoryOutputStreamK a) =>+    a ->                                    -- _obj+    m Word64+memoryOutputStreamGetDataSize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_memory_output_stream_get_data_size _obj'+    touchManagedPtr _obj+    return result++-- method MemoryOutputStream::get_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MemoryOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MemoryOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "g_memory_output_stream_get_size" g_memory_output_stream_get_size :: +    Ptr MemoryOutputStream ->               -- _obj : TInterface "Gio" "MemoryOutputStream"+    IO Word64+++memoryOutputStreamGetSize ::+    (MonadIO m, MemoryOutputStreamK a) =>+    a ->                                    -- _obj+    m Word64+memoryOutputStreamGetSize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_memory_output_stream_get_size _obj'+    touchManagedPtr _obj+    return result++-- method MemoryOutputStream::steal_as_bytes+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MemoryOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MemoryOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GLib" "Bytes"+-- throws : False+-- Skip return : False++foreign import ccall "g_memory_output_stream_steal_as_bytes" g_memory_output_stream_steal_as_bytes :: +    Ptr MemoryOutputStream ->               -- _obj : TInterface "Gio" "MemoryOutputStream"+    IO (Ptr GLib.Bytes)+++memoryOutputStreamStealAsBytes ::+    (MonadIO m, MemoryOutputStreamK a) =>+    a ->                                    -- _obj+    m GLib.Bytes+memoryOutputStreamStealAsBytes _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_memory_output_stream_steal_as_bytes _obj'+    checkUnexpectedReturnNULL "g_memory_output_stream_steal_as_bytes" result+    result' <- (wrapBoxed GLib.Bytes) result+    touchManagedPtr _obj+    return result'++-- method MemoryOutputStream::steal_data+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MemoryOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MemoryOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_memory_output_stream_steal_data" g_memory_output_stream_steal_data :: +    Ptr MemoryOutputStream ->               -- _obj : TInterface "Gio" "MemoryOutputStream"+    IO ()+++memoryOutputStreamStealData ::+    (MonadIO m, MemoryOutputStreamK a) =>+    a ->                                    -- _obj+    m ()+memoryOutputStreamStealData _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_memory_output_stream_steal_data _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Objects/MemoryOutputStream.hs-boot view
@@ -0,0 +1,16 @@+module GI.Gio.Objects.MemoryOutputStream where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype MemoryOutputStream = MemoryOutputStream (ForeignPtr MemoryOutputStream)+instance GObject MemoryOutputStream where+class GObject o => MemoryOutputStreamK o+instance (GObject o, IsDescendantOf MemoryOutputStream o) => MemoryOutputStreamK o+data MemoryOutputStreamDataPropertyInfo+data MemoryOutputStreamDataSizePropertyInfo+data MemoryOutputStreamSizePropertyInfo
+ GI/Gio/Objects/Menu.hs view
@@ -0,0 +1,649 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.Menu+    ( ++-- * Exported types+    Menu(..)                                ,+    MenuK                                   ,+    toMenu                                  ,+    noMenu                                  ,+++ -- * Methods+-- ** menuAppend+    menuAppend                              ,+++-- ** menuAppendItem+    menuAppendItem                          ,+++-- ** menuAppendSection+    menuAppendSection                       ,+++-- ** menuAppendSubmenu+    menuAppendSubmenu                       ,+++-- ** menuFreeze+    menuFreeze                              ,+++-- ** menuInsert+    menuInsert                              ,+++-- ** menuInsertItem+    menuInsertItem                          ,+++-- ** menuInsertSection+    menuInsertSection                       ,+++-- ** menuInsertSubmenu+    menuInsertSubmenu                       ,+++-- ** menuNew+    menuNew                                 ,+++-- ** menuPrepend+    menuPrepend                             ,+++-- ** menuPrependItem+    menuPrependItem                         ,+++-- ** menuPrependSection+    menuPrependSection                      ,+++-- ** menuPrependSubmenu+    menuPrependSubmenu                      ,+++-- ** menuRemove+    menuRemove                              ,+++-- ** menuRemoveAll+    menuRemoveAll                           ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype Menu = Menu (ForeignPtr Menu)+foreign import ccall "g_menu_get_type"+    c_g_menu_get_type :: IO GType++type instance ParentTypes Menu = MenuParentTypes+type MenuParentTypes = '[MenuModel, GObject.Object]++instance GObject Menu where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_menu_get_type+    ++class GObject o => MenuK o+instance (GObject o, IsDescendantOf Menu o) => MenuK o++toMenu :: MenuK o => o -> IO Menu+toMenu = unsafeCastTo Menu++noMenu :: Maybe Menu+noMenu = Nothing++type instance AttributeList Menu = MenuAttributeList+type MenuAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList Menu = MenuSignalList+type MenuSignalList = ('[ '("items-changed", MenuModelItemsChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Menu::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gio" "Menu"+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_new" g_menu_new :: +    IO (Ptr Menu)+++menuNew ::+    (MonadIO m) =>+    m Menu+menuNew  = liftIO $ do+    result <- g_menu_new+    checkUnexpectedReturnNULL "g_menu_new" result+    result' <- (wrapObject Menu) result+    return result'++-- method Menu::append+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detailed_action", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detailed_action", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_append" g_menu_append :: +    Ptr Menu ->                             -- _obj : TInterface "Gio" "Menu"+    CString ->                              -- label : TBasicType TUTF8+    CString ->                              -- detailed_action : TBasicType TUTF8+    IO ()+++menuAppend ::+    (MonadIO m, MenuK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- label+    Maybe (T.Text) ->                       -- detailed_action+    m ()+menuAppend _obj label detailed_action = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeLabel <- case label of+        Nothing -> return nullPtr+        Just jLabel -> do+            jLabel' <- textToCString jLabel+            return jLabel'+    maybeDetailed_action <- case detailed_action of+        Nothing -> return nullPtr+        Just jDetailed_action -> do+            jDetailed_action' <- textToCString jDetailed_action+            return jDetailed_action'+    g_menu_append _obj' maybeLabel maybeDetailed_action+    touchManagedPtr _obj+    freeMem maybeLabel+    freeMem maybeDetailed_action+    return ()++-- method Menu::append_item+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "item", argType = TInterface "Gio" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "item", argType = TInterface "Gio" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_append_item" g_menu_append_item :: +    Ptr Menu ->                             -- _obj : TInterface "Gio" "Menu"+    Ptr MenuItem ->                         -- item : TInterface "Gio" "MenuItem"+    IO ()+++menuAppendItem ::+    (MonadIO m, MenuK a, MenuItemK b) =>+    a ->                                    -- _obj+    b ->                                    -- item+    m ()+menuAppendItem _obj item = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let item' = unsafeManagedPtrCastPtr item+    g_menu_append_item _obj' item'+    touchManagedPtr _obj+    touchManagedPtr item+    return ()++-- method Menu::append_section+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "section", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "section", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_append_section" g_menu_append_section :: +    Ptr Menu ->                             -- _obj : TInterface "Gio" "Menu"+    CString ->                              -- label : TBasicType TUTF8+    Ptr MenuModel ->                        -- section : TInterface "Gio" "MenuModel"+    IO ()+++menuAppendSection ::+    (MonadIO m, MenuK a, MenuModelK b) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- label+    b ->                                    -- section+    m ()+menuAppendSection _obj label section = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeLabel <- case label of+        Nothing -> return nullPtr+        Just jLabel -> do+            jLabel' <- textToCString jLabel+            return jLabel'+    let section' = unsafeManagedPtrCastPtr section+    g_menu_append_section _obj' maybeLabel section'+    touchManagedPtr _obj+    touchManagedPtr section+    freeMem maybeLabel+    return ()++-- method Menu::append_submenu+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "submenu", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "submenu", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_append_submenu" g_menu_append_submenu :: +    Ptr Menu ->                             -- _obj : TInterface "Gio" "Menu"+    CString ->                              -- label : TBasicType TUTF8+    Ptr MenuModel ->                        -- submenu : TInterface "Gio" "MenuModel"+    IO ()+++menuAppendSubmenu ::+    (MonadIO m, MenuK a, MenuModelK b) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- label+    b ->                                    -- submenu+    m ()+menuAppendSubmenu _obj label submenu = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeLabel <- case label of+        Nothing -> return nullPtr+        Just jLabel -> do+            jLabel' <- textToCString jLabel+            return jLabel'+    let submenu' = unsafeManagedPtrCastPtr submenu+    g_menu_append_submenu _obj' maybeLabel submenu'+    touchManagedPtr _obj+    touchManagedPtr submenu+    freeMem maybeLabel+    return ()++-- method Menu::freeze+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_freeze" g_menu_freeze :: +    Ptr Menu ->                             -- _obj : TInterface "Gio" "Menu"+    IO ()+++menuFreeze ::+    (MonadIO m, MenuK a) =>+    a ->                                    -- _obj+    m ()+menuFreeze _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_menu_freeze _obj'+    touchManagedPtr _obj+    return ()++-- method Menu::insert+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detailed_action", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detailed_action", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_insert" g_menu_insert :: +    Ptr Menu ->                             -- _obj : TInterface "Gio" "Menu"+    Int32 ->                                -- position : TBasicType TInt32+    CString ->                              -- label : TBasicType TUTF8+    CString ->                              -- detailed_action : TBasicType TUTF8+    IO ()+++menuInsert ::+    (MonadIO m, MenuK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- position+    Maybe (T.Text) ->                       -- label+    Maybe (T.Text) ->                       -- detailed_action+    m ()+menuInsert _obj position label detailed_action = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeLabel <- case label of+        Nothing -> return nullPtr+        Just jLabel -> do+            jLabel' <- textToCString jLabel+            return jLabel'+    maybeDetailed_action <- case detailed_action of+        Nothing -> return nullPtr+        Just jDetailed_action -> do+            jDetailed_action' <- textToCString jDetailed_action+            return jDetailed_action'+    g_menu_insert _obj' position maybeLabel maybeDetailed_action+    touchManagedPtr _obj+    freeMem maybeLabel+    freeMem maybeDetailed_action+    return ()++-- method Menu::insert_item+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "item", argType = TInterface "Gio" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "item", argType = TInterface "Gio" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_insert_item" g_menu_insert_item :: +    Ptr Menu ->                             -- _obj : TInterface "Gio" "Menu"+    Int32 ->                                -- position : TBasicType TInt32+    Ptr MenuItem ->                         -- item : TInterface "Gio" "MenuItem"+    IO ()+++menuInsertItem ::+    (MonadIO m, MenuK a, MenuItemK b) =>+    a ->                                    -- _obj+    Int32 ->                                -- position+    b ->                                    -- item+    m ()+menuInsertItem _obj position item = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let item' = unsafeManagedPtrCastPtr item+    g_menu_insert_item _obj' position item'+    touchManagedPtr _obj+    touchManagedPtr item+    return ()++-- method Menu::insert_section+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "section", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "section", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_insert_section" g_menu_insert_section :: +    Ptr Menu ->                             -- _obj : TInterface "Gio" "Menu"+    Int32 ->                                -- position : TBasicType TInt32+    CString ->                              -- label : TBasicType TUTF8+    Ptr MenuModel ->                        -- section : TInterface "Gio" "MenuModel"+    IO ()+++menuInsertSection ::+    (MonadIO m, MenuK a, MenuModelK b) =>+    a ->                                    -- _obj+    Int32 ->                                -- position+    Maybe (T.Text) ->                       -- label+    b ->                                    -- section+    m ()+menuInsertSection _obj position label section = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeLabel <- case label of+        Nothing -> return nullPtr+        Just jLabel -> do+            jLabel' <- textToCString jLabel+            return jLabel'+    let section' = unsafeManagedPtrCastPtr section+    g_menu_insert_section _obj' position maybeLabel section'+    touchManagedPtr _obj+    touchManagedPtr section+    freeMem maybeLabel+    return ()++-- method Menu::insert_submenu+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "submenu", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "submenu", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_insert_submenu" g_menu_insert_submenu :: +    Ptr Menu ->                             -- _obj : TInterface "Gio" "Menu"+    Int32 ->                                -- position : TBasicType TInt32+    CString ->                              -- label : TBasicType TUTF8+    Ptr MenuModel ->                        -- submenu : TInterface "Gio" "MenuModel"+    IO ()+++menuInsertSubmenu ::+    (MonadIO m, MenuK a, MenuModelK b) =>+    a ->                                    -- _obj+    Int32 ->                                -- position+    Maybe (T.Text) ->                       -- label+    b ->                                    -- submenu+    m ()+menuInsertSubmenu _obj position label submenu = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeLabel <- case label of+        Nothing -> return nullPtr+        Just jLabel -> do+            jLabel' <- textToCString jLabel+            return jLabel'+    let submenu' = unsafeManagedPtrCastPtr submenu+    g_menu_insert_submenu _obj' position maybeLabel submenu'+    touchManagedPtr _obj+    touchManagedPtr submenu+    freeMem maybeLabel+    return ()++-- method Menu::prepend+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detailed_action", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detailed_action", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_prepend" g_menu_prepend :: +    Ptr Menu ->                             -- _obj : TInterface "Gio" "Menu"+    CString ->                              -- label : TBasicType TUTF8+    CString ->                              -- detailed_action : TBasicType TUTF8+    IO ()+++menuPrepend ::+    (MonadIO m, MenuK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- label+    Maybe (T.Text) ->                       -- detailed_action+    m ()+menuPrepend _obj label detailed_action = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeLabel <- case label of+        Nothing -> return nullPtr+        Just jLabel -> do+            jLabel' <- textToCString jLabel+            return jLabel'+    maybeDetailed_action <- case detailed_action of+        Nothing -> return nullPtr+        Just jDetailed_action -> do+            jDetailed_action' <- textToCString jDetailed_action+            return jDetailed_action'+    g_menu_prepend _obj' maybeLabel maybeDetailed_action+    touchManagedPtr _obj+    freeMem maybeLabel+    freeMem maybeDetailed_action+    return ()++-- method Menu::prepend_item+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "item", argType = TInterface "Gio" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "item", argType = TInterface "Gio" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_prepend_item" g_menu_prepend_item :: +    Ptr Menu ->                             -- _obj : TInterface "Gio" "Menu"+    Ptr MenuItem ->                         -- item : TInterface "Gio" "MenuItem"+    IO ()+++menuPrependItem ::+    (MonadIO m, MenuK a, MenuItemK b) =>+    a ->                                    -- _obj+    b ->                                    -- item+    m ()+menuPrependItem _obj item = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let item' = unsafeManagedPtrCastPtr item+    g_menu_prepend_item _obj' item'+    touchManagedPtr _obj+    touchManagedPtr item+    return ()++-- method Menu::prepend_section+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "section", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "section", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_prepend_section" g_menu_prepend_section :: +    Ptr Menu ->                             -- _obj : TInterface "Gio" "Menu"+    CString ->                              -- label : TBasicType TUTF8+    Ptr MenuModel ->                        -- section : TInterface "Gio" "MenuModel"+    IO ()+++menuPrependSection ::+    (MonadIO m, MenuK a, MenuModelK b) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- label+    b ->                                    -- section+    m ()+menuPrependSection _obj label section = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeLabel <- case label of+        Nothing -> return nullPtr+        Just jLabel -> do+            jLabel' <- textToCString jLabel+            return jLabel'+    let section' = unsafeManagedPtrCastPtr section+    g_menu_prepend_section _obj' maybeLabel section'+    touchManagedPtr _obj+    touchManagedPtr section+    freeMem maybeLabel+    return ()++-- method Menu::prepend_submenu+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "submenu", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "submenu", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_prepend_submenu" g_menu_prepend_submenu :: +    Ptr Menu ->                             -- _obj : TInterface "Gio" "Menu"+    CString ->                              -- label : TBasicType TUTF8+    Ptr MenuModel ->                        -- submenu : TInterface "Gio" "MenuModel"+    IO ()+++menuPrependSubmenu ::+    (MonadIO m, MenuK a, MenuModelK b) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- label+    b ->                                    -- submenu+    m ()+menuPrependSubmenu _obj label submenu = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeLabel <- case label of+        Nothing -> return nullPtr+        Just jLabel -> do+            jLabel' <- textToCString jLabel+            return jLabel'+    let submenu' = unsafeManagedPtrCastPtr submenu+    g_menu_prepend_submenu _obj' maybeLabel submenu'+    touchManagedPtr _obj+    touchManagedPtr submenu+    freeMem maybeLabel+    return ()++-- method Menu::remove+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_remove" g_menu_remove :: +    Ptr Menu ->                             -- _obj : TInterface "Gio" "Menu"+    Int32 ->                                -- position : TBasicType TInt32+    IO ()+++menuRemove ::+    (MonadIO m, MenuK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- position+    m ()+menuRemove _obj position = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_menu_remove _obj' position+    touchManagedPtr _obj+    return ()++-- method Menu::remove_all+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_remove_all" g_menu_remove_all :: +    Ptr Menu ->                             -- _obj : TInterface "Gio" "Menu"+    IO ()+++menuRemoveAll ::+    (MonadIO m, MenuK a) =>+    a ->                                    -- _obj+    m ()+menuRemoveAll _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_menu_remove_all _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Objects/Menu.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Objects.Menu where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Menu = Menu (ForeignPtr Menu)+instance GObject Menu where+class GObject o => MenuK o+instance (GObject o, IsDescendantOf Menu o) => MenuK o
+ GI/Gio/Objects/MenuAttributeIter.hs view
@@ -0,0 +1,189 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.MenuAttributeIter+    ( ++-- * Exported types+    MenuAttributeIter(..)                   ,+    MenuAttributeIterK                      ,+    toMenuAttributeIter                     ,+    noMenuAttributeIter                     ,+++ -- * Methods+-- ** menuAttributeIterGetName+    menuAttributeIterGetName                ,+++-- ** menuAttributeIterGetNext+    menuAttributeIterGetNext                ,+++-- ** menuAttributeIterGetValue+    menuAttributeIterGetValue               ,+++-- ** menuAttributeIterNext+    menuAttributeIterNext                   ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype MenuAttributeIter = MenuAttributeIter (ForeignPtr MenuAttributeIter)+foreign import ccall "g_menu_attribute_iter_get_type"+    c_g_menu_attribute_iter_get_type :: IO GType++type instance ParentTypes MenuAttributeIter = MenuAttributeIterParentTypes+type MenuAttributeIterParentTypes = '[GObject.Object]++instance GObject MenuAttributeIter where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_menu_attribute_iter_get_type+    ++class GObject o => MenuAttributeIterK o+instance (GObject o, IsDescendantOf MenuAttributeIter o) => MenuAttributeIterK o++toMenuAttributeIter :: MenuAttributeIterK o => o -> IO MenuAttributeIter+toMenuAttributeIter = unsafeCastTo MenuAttributeIter++noMenuAttributeIter :: Maybe MenuAttributeIter+noMenuAttributeIter = Nothing++type instance AttributeList MenuAttributeIter = MenuAttributeIterAttributeList+type MenuAttributeIterAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList MenuAttributeIter = MenuAttributeIterSignalList+type MenuAttributeIterSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method MenuAttributeIter::get_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuAttributeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuAttributeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_attribute_iter_get_name" g_menu_attribute_iter_get_name :: +    Ptr MenuAttributeIter ->                -- _obj : TInterface "Gio" "MenuAttributeIter"+    IO CString+++menuAttributeIterGetName ::+    (MonadIO m, MenuAttributeIterK a) =>+    a ->                                    -- _obj+    m T.Text+menuAttributeIterGetName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_menu_attribute_iter_get_name _obj'+    checkUnexpectedReturnNULL "g_menu_attribute_iter_get_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method MenuAttributeIter::get_next+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuAttributeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "out_name", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TVariant, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuAttributeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_attribute_iter_get_next" g_menu_attribute_iter_get_next :: +    Ptr MenuAttributeIter ->                -- _obj : TInterface "Gio" "MenuAttributeIter"+    Ptr CString ->                          -- out_name : TBasicType TUTF8+    Ptr (Ptr GVariant) ->                   -- value : TVariant+    IO CInt+++menuAttributeIterGetNext ::+    (MonadIO m, MenuAttributeIterK a) =>+    a ->                                    -- _obj+    m (Bool,T.Text,GVariant)+menuAttributeIterGetNext _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    out_name <- allocMem :: IO (Ptr CString)+    value <- allocMem :: IO (Ptr (Ptr GVariant))+    result <- g_menu_attribute_iter_get_next _obj' out_name value+    let result' = (/= 0) result+    out_name' <- peek out_name+    out_name'' <- cstringToText out_name'+    value' <- peek value+    value'' <- wrapGVariantPtr value'+    touchManagedPtr _obj+    freeMem out_name+    freeMem value+    return (result', out_name'', value'')++-- method MenuAttributeIter::get_value+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuAttributeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuAttributeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TVariant+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_attribute_iter_get_value" g_menu_attribute_iter_get_value :: +    Ptr MenuAttributeIter ->                -- _obj : TInterface "Gio" "MenuAttributeIter"+    IO (Ptr GVariant)+++menuAttributeIterGetValue ::+    (MonadIO m, MenuAttributeIterK a) =>+    a ->                                    -- _obj+    m GVariant+menuAttributeIterGetValue _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_menu_attribute_iter_get_value _obj'+    checkUnexpectedReturnNULL "g_menu_attribute_iter_get_value" result+    result' <- wrapGVariantPtr result+    touchManagedPtr _obj+    return result'++-- method MenuAttributeIter::next+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuAttributeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuAttributeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_attribute_iter_next" g_menu_attribute_iter_next :: +    Ptr MenuAttributeIter ->                -- _obj : TInterface "Gio" "MenuAttributeIter"+    IO CInt+++menuAttributeIterNext ::+    (MonadIO m, MenuAttributeIterK a) =>+    a ->                                    -- _obj+    m Bool+menuAttributeIterNext _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_menu_attribute_iter_next _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++
+ GI/Gio/Objects/MenuAttributeIter.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Objects.MenuAttributeIter where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype MenuAttributeIter = MenuAttributeIter (ForeignPtr MenuAttributeIter)+instance GObject MenuAttributeIter where+class GObject o => MenuAttributeIterK o+instance (GObject o, IsDescendantOf MenuAttributeIter o) => MenuAttributeIterK o
+ GI/Gio/Objects/MenuItem.hs view
@@ -0,0 +1,582 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.MenuItem+    ( ++-- * Exported types+    MenuItem(..)                            ,+    MenuItemK                               ,+    toMenuItem                              ,+    noMenuItem                              ,+++ -- * Methods+-- ** menuItemGetAttributeValue+    menuItemGetAttributeValue               ,+++-- ** menuItemGetLink+    menuItemGetLink                         ,+++-- ** menuItemNew+    menuItemNew                             ,+++-- ** menuItemNewFromModel+    menuItemNewFromModel                    ,+++-- ** menuItemNewSection+    menuItemNewSection                      ,+++-- ** menuItemNewSubmenu+    menuItemNewSubmenu                      ,+++-- ** menuItemSetActionAndTargetValue+    menuItemSetActionAndTargetValue         ,+++-- ** menuItemSetAttributeValue+    menuItemSetAttributeValue               ,+++-- ** menuItemSetDetailedAction+    menuItemSetDetailedAction               ,+++-- ** menuItemSetIcon+    menuItemSetIcon                         ,+++-- ** menuItemSetLabel+    menuItemSetLabel                        ,+++-- ** menuItemSetLink+    menuItemSetLink                         ,+++-- ** menuItemSetSection+    menuItemSetSection                      ,+++-- ** menuItemSetSubmenu+    menuItemSetSubmenu                      ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype MenuItem = MenuItem (ForeignPtr MenuItem)+foreign import ccall "g_menu_item_get_type"+    c_g_menu_item_get_type :: IO GType++type instance ParentTypes MenuItem = MenuItemParentTypes+type MenuItemParentTypes = '[GObject.Object]++instance GObject MenuItem where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_menu_item_get_type+    ++class GObject o => MenuItemK o+instance (GObject o, IsDescendantOf MenuItem o) => MenuItemK o++toMenuItem :: MenuItemK o => o -> IO MenuItem+toMenuItem = unsafeCastTo MenuItem++noMenuItem :: Maybe MenuItem+noMenuItem = Nothing++type instance AttributeList MenuItem = MenuItemAttributeList+type MenuItemAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList MenuItem = MenuItemSignalList+type MenuItemSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method MenuItem::new+-- method type : Constructor+-- Args : [Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detailed_action", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detailed_action", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "MenuItem"+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_item_new" g_menu_item_new :: +    CString ->                              -- label : TBasicType TUTF8+    CString ->                              -- detailed_action : TBasicType TUTF8+    IO (Ptr MenuItem)+++menuItemNew ::+    (MonadIO m) =>+    Maybe (T.Text) ->                       -- label+    Maybe (T.Text) ->                       -- detailed_action+    m MenuItem+menuItemNew label detailed_action = liftIO $ do+    maybeLabel <- case label of+        Nothing -> return nullPtr+        Just jLabel -> do+            jLabel' <- textToCString jLabel+            return jLabel'+    maybeDetailed_action <- case detailed_action of+        Nothing -> return nullPtr+        Just jDetailed_action -> do+            jDetailed_action' <- textToCString jDetailed_action+            return jDetailed_action'+    result <- g_menu_item_new maybeLabel maybeDetailed_action+    checkUnexpectedReturnNULL "g_menu_item_new" result+    result' <- (wrapObject MenuItem) result+    freeMem maybeLabel+    freeMem maybeDetailed_action+    return result'++-- method MenuItem::new_from_model+-- method type : Constructor+-- Args : [Arg {argName = "model", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "item_index", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "model", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "item_index", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "MenuItem"+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_item_new_from_model" g_menu_item_new_from_model :: +    Ptr MenuModel ->                        -- model : TInterface "Gio" "MenuModel"+    Int32 ->                                -- item_index : TBasicType TInt32+    IO (Ptr MenuItem)+++menuItemNewFromModel ::+    (MonadIO m, MenuModelK a) =>+    a ->                                    -- model+    Int32 ->                                -- item_index+    m MenuItem+menuItemNewFromModel model item_index = liftIO $ do+    let model' = unsafeManagedPtrCastPtr model+    result <- g_menu_item_new_from_model model' item_index+    checkUnexpectedReturnNULL "g_menu_item_new_from_model" result+    result' <- (wrapObject MenuItem) result+    touchManagedPtr model+    return result'++-- method MenuItem::new_section+-- method type : Constructor+-- Args : [Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "section", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "section", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "MenuItem"+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_item_new_section" g_menu_item_new_section :: +    CString ->                              -- label : TBasicType TUTF8+    Ptr MenuModel ->                        -- section : TInterface "Gio" "MenuModel"+    IO (Ptr MenuItem)+++menuItemNewSection ::+    (MonadIO m, MenuModelK a) =>+    Maybe (T.Text) ->                       -- label+    a ->                                    -- section+    m MenuItem+menuItemNewSection label section = liftIO $ do+    maybeLabel <- case label of+        Nothing -> return nullPtr+        Just jLabel -> do+            jLabel' <- textToCString jLabel+            return jLabel'+    let section' = unsafeManagedPtrCastPtr section+    result <- g_menu_item_new_section maybeLabel section'+    checkUnexpectedReturnNULL "g_menu_item_new_section" result+    result' <- (wrapObject MenuItem) result+    touchManagedPtr section+    freeMem maybeLabel+    return result'++-- method MenuItem::new_submenu+-- method type : Constructor+-- Args : [Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "submenu", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "submenu", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "MenuItem"+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_item_new_submenu" g_menu_item_new_submenu :: +    CString ->                              -- label : TBasicType TUTF8+    Ptr MenuModel ->                        -- submenu : TInterface "Gio" "MenuModel"+    IO (Ptr MenuItem)+++menuItemNewSubmenu ::+    (MonadIO m, MenuModelK a) =>+    Maybe (T.Text) ->                       -- label+    a ->                                    -- submenu+    m MenuItem+menuItemNewSubmenu label submenu = liftIO $ do+    maybeLabel <- case label of+        Nothing -> return nullPtr+        Just jLabel -> do+            jLabel' <- textToCString jLabel+            return jLabel'+    let submenu' = unsafeManagedPtrCastPtr submenu+    result <- g_menu_item_new_submenu maybeLabel submenu'+    checkUnexpectedReturnNULL "g_menu_item_new_submenu" result+    result' <- (wrapObject MenuItem) result+    touchManagedPtr submenu+    freeMem maybeLabel+    return result'++-- method MenuItem::get_attribute_value+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "expected_type", argType = TInterface "GLib" "VariantType", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "expected_type", argType = TInterface "GLib" "VariantType", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TVariant+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_item_get_attribute_value" g_menu_item_get_attribute_value :: +    Ptr MenuItem ->                         -- _obj : TInterface "Gio" "MenuItem"+    CString ->                              -- attribute : TBasicType TUTF8+    Ptr GLib.VariantType ->                 -- expected_type : TInterface "GLib" "VariantType"+    IO (Ptr GVariant)+++menuItemGetAttributeValue ::+    (MonadIO m, MenuItemK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    Maybe (GLib.VariantType) ->             -- expected_type+    m GVariant+menuItemGetAttributeValue _obj attribute expected_type = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    maybeExpected_type <- case expected_type of+        Nothing -> return nullPtr+        Just jExpected_type -> do+            let jExpected_type' = unsafeManagedPtrGetPtr jExpected_type+            return jExpected_type'+    result <- g_menu_item_get_attribute_value _obj' attribute' maybeExpected_type+    checkUnexpectedReturnNULL "g_menu_item_get_attribute_value" result+    result' <- wrapGVariantPtr result+    touchManagedPtr _obj+    whenJust expected_type touchManagedPtr+    freeMem attribute'+    return result'++-- method MenuItem::get_link+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "link", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "link", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "MenuModel"+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_item_get_link" g_menu_item_get_link :: +    Ptr MenuItem ->                         -- _obj : TInterface "Gio" "MenuItem"+    CString ->                              -- link : TBasicType TUTF8+    IO (Ptr MenuModel)+++menuItemGetLink ::+    (MonadIO m, MenuItemK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- link+    m MenuModel+menuItemGetLink _obj link = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    link' <- textToCString link+    result <- g_menu_item_get_link _obj' link'+    checkUnexpectedReturnNULL "g_menu_item_get_link" result+    result' <- (wrapObject MenuModel) result+    touchManagedPtr _obj+    freeMem link'+    return result'++-- method MenuItem::set_action_and_target_value+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "target_value", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "target_value", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_item_set_action_and_target_value" g_menu_item_set_action_and_target_value :: +    Ptr MenuItem ->                         -- _obj : TInterface "Gio" "MenuItem"+    CString ->                              -- action : TBasicType TUTF8+    Ptr GVariant ->                         -- target_value : TVariant+    IO ()+++menuItemSetActionAndTargetValue ::+    (MonadIO m, MenuItemK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- action+    Maybe (GVariant) ->                     -- target_value+    m ()+menuItemSetActionAndTargetValue _obj action target_value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeAction <- case action of+        Nothing -> return nullPtr+        Just jAction -> do+            jAction' <- textToCString jAction+            return jAction'+    maybeTarget_value <- case target_value of+        Nothing -> return nullPtr+        Just jTarget_value -> do+            let jTarget_value' = unsafeManagedPtrGetPtr jTarget_value+            return jTarget_value'+    g_menu_item_set_action_and_target_value _obj' maybeAction maybeTarget_value+    touchManagedPtr _obj+    freeMem maybeAction+    return ()++-- method MenuItem::set_attribute_value+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_item_set_attribute_value" g_menu_item_set_attribute_value :: +    Ptr MenuItem ->                         -- _obj : TInterface "Gio" "MenuItem"+    CString ->                              -- attribute : TBasicType TUTF8+    Ptr GVariant ->                         -- value : TVariant+    IO ()+++menuItemSetAttributeValue ::+    (MonadIO m, MenuItemK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- attribute+    Maybe (GVariant) ->                     -- value+    m ()+menuItemSetAttributeValue _obj attribute value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    maybeValue <- case value of+        Nothing -> return nullPtr+        Just jValue -> do+            let jValue' = unsafeManagedPtrGetPtr jValue+            return jValue'+    g_menu_item_set_attribute_value _obj' attribute' maybeValue+    touchManagedPtr _obj+    freeMem attribute'+    return ()++-- method MenuItem::set_detailed_action+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detailed_action", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detailed_action", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_item_set_detailed_action" g_menu_item_set_detailed_action :: +    Ptr MenuItem ->                         -- _obj : TInterface "Gio" "MenuItem"+    CString ->                              -- detailed_action : TBasicType TUTF8+    IO ()+++menuItemSetDetailedAction ::+    (MonadIO m, MenuItemK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- detailed_action+    m ()+menuItemSetDetailedAction _obj detailed_action = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    detailed_action' <- textToCString detailed_action+    g_menu_item_set_detailed_action _obj' detailed_action'+    touchManagedPtr _obj+    freeMem detailed_action'+    return ()++-- method MenuItem::set_icon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon", argType = TInterface "Gio" "Icon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon", argType = TInterface "Gio" "Icon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_item_set_icon" g_menu_item_set_icon :: +    Ptr MenuItem ->                         -- _obj : TInterface "Gio" "MenuItem"+    Ptr Icon ->                             -- icon : TInterface "Gio" "Icon"+    IO ()+++menuItemSetIcon ::+    (MonadIO m, MenuItemK a, IconK b) =>+    a ->                                    -- _obj+    b ->                                    -- icon+    m ()+menuItemSetIcon _obj icon = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let icon' = unsafeManagedPtrCastPtr icon+    g_menu_item_set_icon _obj' icon'+    touchManagedPtr _obj+    touchManagedPtr icon+    return ()++-- method MenuItem::set_label+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_item_set_label" g_menu_item_set_label :: +    Ptr MenuItem ->                         -- _obj : TInterface "Gio" "MenuItem"+    CString ->                              -- label : TBasicType TUTF8+    IO ()+++menuItemSetLabel ::+    (MonadIO m, MenuItemK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- label+    m ()+menuItemSetLabel _obj label = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeLabel <- case label of+        Nothing -> return nullPtr+        Just jLabel -> do+            jLabel' <- textToCString jLabel+            return jLabel'+    g_menu_item_set_label _obj' maybeLabel+    touchManagedPtr _obj+    freeMem maybeLabel+    return ()++-- method MenuItem::set_link+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "link", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "model", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "link", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "model", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_item_set_link" g_menu_item_set_link :: +    Ptr MenuItem ->                         -- _obj : TInterface "Gio" "MenuItem"+    CString ->                              -- link : TBasicType TUTF8+    Ptr MenuModel ->                        -- model : TInterface "Gio" "MenuModel"+    IO ()+++menuItemSetLink ::+    (MonadIO m, MenuItemK a, MenuModelK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- link+    Maybe (b) ->                            -- model+    m ()+menuItemSetLink _obj link model = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    link' <- textToCString link+    maybeModel <- case model of+        Nothing -> return nullPtr+        Just jModel -> do+            let jModel' = unsafeManagedPtrCastPtr jModel+            return jModel'+    g_menu_item_set_link _obj' link' maybeModel+    touchManagedPtr _obj+    whenJust model touchManagedPtr+    freeMem link'+    return ()++-- method MenuItem::set_section+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "section", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "section", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_item_set_section" g_menu_item_set_section :: +    Ptr MenuItem ->                         -- _obj : TInterface "Gio" "MenuItem"+    Ptr MenuModel ->                        -- section : TInterface "Gio" "MenuModel"+    IO ()+++menuItemSetSection ::+    (MonadIO m, MenuItemK a, MenuModelK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- section+    m ()+menuItemSetSection _obj section = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeSection <- case section of+        Nothing -> return nullPtr+        Just jSection -> do+            let jSection' = unsafeManagedPtrCastPtr jSection+            return jSection'+    g_menu_item_set_section _obj' maybeSection+    touchManagedPtr _obj+    whenJust section touchManagedPtr+    return ()++-- method MenuItem::set_submenu+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "submenu", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "submenu", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_item_set_submenu" g_menu_item_set_submenu :: +    Ptr MenuItem ->                         -- _obj : TInterface "Gio" "MenuItem"+    Ptr MenuModel ->                        -- submenu : TInterface "Gio" "MenuModel"+    IO ()+++menuItemSetSubmenu ::+    (MonadIO m, MenuItemK a, MenuModelK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- submenu+    m ()+menuItemSetSubmenu _obj submenu = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeSubmenu <- case submenu of+        Nothing -> return nullPtr+        Just jSubmenu -> do+            let jSubmenu' = unsafeManagedPtrCastPtr jSubmenu+            return jSubmenu'+    g_menu_item_set_submenu _obj' maybeSubmenu+    touchManagedPtr _obj+    whenJust submenu touchManagedPtr+    return ()++
+ GI/Gio/Objects/MenuItem.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Objects.MenuItem where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype MenuItem = MenuItem (ForeignPtr MenuItem)+instance GObject MenuItem where+class GObject o => MenuItemK o+instance (GObject o, IsDescendantOf MenuItem o) => MenuItemK o
+ GI/Gio/Objects/MenuLinkIter.hs view
@@ -0,0 +1,189 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.MenuLinkIter+    ( ++-- * Exported types+    MenuLinkIter(..)                        ,+    MenuLinkIterK                           ,+    toMenuLinkIter                          ,+    noMenuLinkIter                          ,+++ -- * Methods+-- ** menuLinkIterGetName+    menuLinkIterGetName                     ,+++-- ** menuLinkIterGetNext+    menuLinkIterGetNext                     ,+++-- ** menuLinkIterGetValue+    menuLinkIterGetValue                    ,+++-- ** menuLinkIterNext+    menuLinkIterNext                        ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype MenuLinkIter = MenuLinkIter (ForeignPtr MenuLinkIter)+foreign import ccall "g_menu_link_iter_get_type"+    c_g_menu_link_iter_get_type :: IO GType++type instance ParentTypes MenuLinkIter = MenuLinkIterParentTypes+type MenuLinkIterParentTypes = '[GObject.Object]++instance GObject MenuLinkIter where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_menu_link_iter_get_type+    ++class GObject o => MenuLinkIterK o+instance (GObject o, IsDescendantOf MenuLinkIter o) => MenuLinkIterK o++toMenuLinkIter :: MenuLinkIterK o => o -> IO MenuLinkIter+toMenuLinkIter = unsafeCastTo MenuLinkIter++noMenuLinkIter :: Maybe MenuLinkIter+noMenuLinkIter = Nothing++type instance AttributeList MenuLinkIter = MenuLinkIterAttributeList+type MenuLinkIterAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList MenuLinkIter = MenuLinkIterSignalList+type MenuLinkIterSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method MenuLinkIter::get_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuLinkIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuLinkIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_link_iter_get_name" g_menu_link_iter_get_name :: +    Ptr MenuLinkIter ->                     -- _obj : TInterface "Gio" "MenuLinkIter"+    IO CString+++menuLinkIterGetName ::+    (MonadIO m, MenuLinkIterK a) =>+    a ->                                    -- _obj+    m T.Text+menuLinkIterGetName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_menu_link_iter_get_name _obj'+    checkUnexpectedReturnNULL "g_menu_link_iter_get_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method MenuLinkIter::get_next+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuLinkIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "out_link", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TInterface "Gio" "MenuModel", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuLinkIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_link_iter_get_next" g_menu_link_iter_get_next :: +    Ptr MenuLinkIter ->                     -- _obj : TInterface "Gio" "MenuLinkIter"+    Ptr CString ->                          -- out_link : TBasicType TUTF8+    Ptr (Ptr MenuModel) ->                  -- value : TInterface "Gio" "MenuModel"+    IO CInt+++menuLinkIterGetNext ::+    (MonadIO m, MenuLinkIterK a) =>+    a ->                                    -- _obj+    m (Bool,T.Text,MenuModel)+menuLinkIterGetNext _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    out_link <- allocMem :: IO (Ptr CString)+    value <- allocMem :: IO (Ptr (Ptr MenuModel))+    result <- g_menu_link_iter_get_next _obj' out_link value+    let result' = (/= 0) result+    out_link' <- peek out_link+    out_link'' <- cstringToText out_link'+    value' <- peek value+    value'' <- (wrapObject MenuModel) value'+    touchManagedPtr _obj+    freeMem out_link+    freeMem value+    return (result', out_link'', value'')++-- method MenuLinkIter::get_value+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuLinkIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuLinkIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "MenuModel"+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_link_iter_get_value" g_menu_link_iter_get_value :: +    Ptr MenuLinkIter ->                     -- _obj : TInterface "Gio" "MenuLinkIter"+    IO (Ptr MenuModel)+++menuLinkIterGetValue ::+    (MonadIO m, MenuLinkIterK a) =>+    a ->                                    -- _obj+    m MenuModel+menuLinkIterGetValue _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_menu_link_iter_get_value _obj'+    checkUnexpectedReturnNULL "g_menu_link_iter_get_value" result+    result' <- (wrapObject MenuModel) result+    touchManagedPtr _obj+    return result'++-- method MenuLinkIter::next+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuLinkIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuLinkIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_link_iter_next" g_menu_link_iter_next :: +    Ptr MenuLinkIter ->                     -- _obj : TInterface "Gio" "MenuLinkIter"+    IO CInt+++menuLinkIterNext ::+    (MonadIO m, MenuLinkIterK a) =>+    a ->                                    -- _obj+    m Bool+menuLinkIterNext _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_menu_link_iter_next _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++
+ GI/Gio/Objects/MenuLinkIter.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Objects.MenuLinkIter where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype MenuLinkIter = MenuLinkIter (ForeignPtr MenuLinkIter)+instance GObject MenuLinkIter where+class GObject o => MenuLinkIterK o+instance (GObject o, IsDescendantOf MenuLinkIter o) => MenuLinkIterK o
+ GI/Gio/Objects/MenuModel.hs view
@@ -0,0 +1,364 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.MenuModel+    ( ++-- * Exported types+    MenuModel(..)                           ,+    MenuModelK                              ,+    toMenuModel                             ,+    noMenuModel                             ,+++ -- * Methods+-- ** menuModelGetItemAttributeValue+    menuModelGetItemAttributeValue          ,+++-- ** menuModelGetItemLink+    menuModelGetItemLink                    ,+++-- ** menuModelGetNItems+    menuModelGetNItems                      ,+++-- ** menuModelIsMutable+    menuModelIsMutable                      ,+++-- ** menuModelItemsChanged+    menuModelItemsChanged                   ,+++-- ** menuModelIterateItemAttributes+    menuModelIterateItemAttributes          ,+++-- ** menuModelIterateItemLinks+    menuModelIterateItemLinks               ,+++++ -- * Signals+-- ** ItemsChanged+    MenuModelItemsChangedCallback           ,+    MenuModelItemsChangedCallbackC          ,+    MenuModelItemsChangedSignalInfo         ,+    afterMenuModelItemsChanged              ,+    menuModelItemsChangedCallbackWrapper    ,+    menuModelItemsChangedClosure            ,+    mkMenuModelItemsChangedCallback         ,+    noMenuModelItemsChangedCallback         ,+    onMenuModelItemsChanged                 ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype MenuModel = MenuModel (ForeignPtr MenuModel)+foreign import ccall "g_menu_model_get_type"+    c_g_menu_model_get_type :: IO GType++type instance ParentTypes MenuModel = MenuModelParentTypes+type MenuModelParentTypes = '[GObject.Object]++instance GObject MenuModel where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_menu_model_get_type+    ++class GObject o => MenuModelK o+instance (GObject o, IsDescendantOf MenuModel o) => MenuModelK o++toMenuModel :: MenuModelK o => o -> IO MenuModel+toMenuModel = unsafeCastTo MenuModel++noMenuModel :: Maybe MenuModel+noMenuModel = Nothing++-- signal MenuModel::items-changed+type MenuModelItemsChangedCallback =+    Int32 ->+    Int32 ->+    Int32 ->+    IO ()++noMenuModelItemsChangedCallback :: Maybe MenuModelItemsChangedCallback+noMenuModelItemsChangedCallback = Nothing++type MenuModelItemsChangedCallbackC =+    Ptr () ->                               -- object+    Int32 ->+    Int32 ->+    Int32 ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkMenuModelItemsChangedCallback :: MenuModelItemsChangedCallbackC -> IO (FunPtr MenuModelItemsChangedCallbackC)++menuModelItemsChangedClosure :: MenuModelItemsChangedCallback -> IO Closure+menuModelItemsChangedClosure cb = newCClosure =<< mkMenuModelItemsChangedCallback wrapped+    where wrapped = menuModelItemsChangedCallbackWrapper cb++menuModelItemsChangedCallbackWrapper ::+    MenuModelItemsChangedCallback ->+    Ptr () ->+    Int32 ->+    Int32 ->+    Int32 ->+    Ptr () ->+    IO ()+menuModelItemsChangedCallbackWrapper _cb _ position removed added _ = do+    _cb  position removed added++onMenuModelItemsChanged :: (GObject a, MonadIO m) => a -> MenuModelItemsChangedCallback -> m SignalHandlerId+onMenuModelItemsChanged obj cb = liftIO $ connectMenuModelItemsChanged obj cb SignalConnectBefore+afterMenuModelItemsChanged :: (GObject a, MonadIO m) => a -> MenuModelItemsChangedCallback -> m SignalHandlerId+afterMenuModelItemsChanged obj cb = connectMenuModelItemsChanged obj cb SignalConnectAfter++connectMenuModelItemsChanged :: (GObject a, MonadIO m) =>+                                a -> MenuModelItemsChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectMenuModelItemsChanged obj cb after = liftIO $ do+    cb' <- mkMenuModelItemsChangedCallback (menuModelItemsChangedCallbackWrapper cb)+    connectSignalFunPtr obj "items-changed" cb' after++type instance AttributeList MenuModel = MenuModelAttributeList+type MenuModelAttributeList = ('[ ] :: [(Symbol, *)])++data MenuModelItemsChangedSignalInfo+instance SignalInfo MenuModelItemsChangedSignalInfo where+    type HaskellCallbackType MenuModelItemsChangedSignalInfo = MenuModelItemsChangedCallback+    connectSignal _ = connectMenuModelItemsChanged++type instance SignalList MenuModel = MenuModelSignalList+type MenuModelSignalList = ('[ '("items-changed", MenuModelItemsChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method MenuModel::get_item_attribute_value+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "item_index", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "expected_type", argType = TInterface "GLib" "VariantType", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "item_index", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "expected_type", argType = TInterface "GLib" "VariantType", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TVariant+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_model_get_item_attribute_value" g_menu_model_get_item_attribute_value :: +    Ptr MenuModel ->                        -- _obj : TInterface "Gio" "MenuModel"+    Int32 ->                                -- item_index : TBasicType TInt32+    CString ->                              -- attribute : TBasicType TUTF8+    Ptr GLib.VariantType ->                 -- expected_type : TInterface "GLib" "VariantType"+    IO (Ptr GVariant)+++menuModelGetItemAttributeValue ::+    (MonadIO m, MenuModelK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- item_index+    T.Text ->                               -- attribute+    Maybe (GLib.VariantType) ->             -- expected_type+    m GVariant+menuModelGetItemAttributeValue _obj item_index attribute expected_type = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    attribute' <- textToCString attribute+    maybeExpected_type <- case expected_type of+        Nothing -> return nullPtr+        Just jExpected_type -> do+            let jExpected_type' = unsafeManagedPtrGetPtr jExpected_type+            return jExpected_type'+    result <- g_menu_model_get_item_attribute_value _obj' item_index attribute' maybeExpected_type+    checkUnexpectedReturnNULL "g_menu_model_get_item_attribute_value" result+    result' <- wrapGVariantPtr result+    touchManagedPtr _obj+    whenJust expected_type touchManagedPtr+    freeMem attribute'+    return result'++-- method MenuModel::get_item_link+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "item_index", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "link", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "item_index", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "link", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "MenuModel"+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_model_get_item_link" g_menu_model_get_item_link :: +    Ptr MenuModel ->                        -- _obj : TInterface "Gio" "MenuModel"+    Int32 ->                                -- item_index : TBasicType TInt32+    CString ->                              -- link : TBasicType TUTF8+    IO (Ptr MenuModel)+++menuModelGetItemLink ::+    (MonadIO m, MenuModelK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- item_index+    T.Text ->                               -- link+    m MenuModel+menuModelGetItemLink _obj item_index link = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    link' <- textToCString link+    result <- g_menu_model_get_item_link _obj' item_index link'+    checkUnexpectedReturnNULL "g_menu_model_get_item_link" result+    result' <- (wrapObject MenuModel) result+    touchManagedPtr _obj+    freeMem link'+    return result'++-- method MenuModel::get_n_items+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_model_get_n_items" g_menu_model_get_n_items :: +    Ptr MenuModel ->                        -- _obj : TInterface "Gio" "MenuModel"+    IO Int32+++menuModelGetNItems ::+    (MonadIO m, MenuModelK a) =>+    a ->                                    -- _obj+    m Int32+menuModelGetNItems _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_menu_model_get_n_items _obj'+    touchManagedPtr _obj+    return result++-- method MenuModel::is_mutable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_model_is_mutable" g_menu_model_is_mutable :: +    Ptr MenuModel ->                        -- _obj : TInterface "Gio" "MenuModel"+    IO CInt+++menuModelIsMutable ::+    (MonadIO m, MenuModelK a) =>+    a ->                                    -- _obj+    m Bool+menuModelIsMutable _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_menu_model_is_mutable _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method MenuModel::items_changed+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "removed", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "added", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "removed", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "added", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_model_items_changed" g_menu_model_items_changed :: +    Ptr MenuModel ->                        -- _obj : TInterface "Gio" "MenuModel"+    Int32 ->                                -- position : TBasicType TInt32+    Int32 ->                                -- removed : TBasicType TInt32+    Int32 ->                                -- added : TBasicType TInt32+    IO ()+++menuModelItemsChanged ::+    (MonadIO m, MenuModelK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- position+    Int32 ->                                -- removed+    Int32 ->                                -- added+    m ()+menuModelItemsChanged _obj position removed added = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_menu_model_items_changed _obj' position removed added+    touchManagedPtr _obj+    return ()++-- method MenuModel::iterate_item_attributes+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "item_index", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "item_index", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "MenuAttributeIter"+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_model_iterate_item_attributes" g_menu_model_iterate_item_attributes :: +    Ptr MenuModel ->                        -- _obj : TInterface "Gio" "MenuModel"+    Int32 ->                                -- item_index : TBasicType TInt32+    IO (Ptr MenuAttributeIter)+++menuModelIterateItemAttributes ::+    (MonadIO m, MenuModelK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- item_index+    m MenuAttributeIter+menuModelIterateItemAttributes _obj item_index = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_menu_model_iterate_item_attributes _obj' item_index+    checkUnexpectedReturnNULL "g_menu_model_iterate_item_attributes" result+    result' <- (wrapObject MenuAttributeIter) result+    touchManagedPtr _obj+    return result'++-- method MenuModel::iterate_item_links+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "item_index", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "item_index", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "MenuLinkIter"+-- throws : False+-- Skip return : False++foreign import ccall "g_menu_model_iterate_item_links" g_menu_model_iterate_item_links :: +    Ptr MenuModel ->                        -- _obj : TInterface "Gio" "MenuModel"+    Int32 ->                                -- item_index : TBasicType TInt32+    IO (Ptr MenuLinkIter)+++menuModelIterateItemLinks ::+    (MonadIO m, MenuModelK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- item_index+    m MenuLinkIter+menuModelIterateItemLinks _obj item_index = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_menu_model_iterate_item_links _obj' item_index+    checkUnexpectedReturnNULL "g_menu_model_iterate_item_links" result+    result' <- (wrapObject MenuLinkIter) result+    touchManagedPtr _obj+    return result'++
+ GI/Gio/Objects/MenuModel.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gio.Objects.MenuModel where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype MenuModel = MenuModel (ForeignPtr MenuModel)+instance GObject MenuModel where+class GObject o => MenuModelK o+instance (GObject o, IsDescendantOf MenuModel o) => MenuModelK o+data MenuModelItemsChangedSignalInfo
+ GI/Gio/Objects/MountOperation.hs view
@@ -0,0 +1,1054 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.MountOperation+    ( ++-- * Exported types+    MountOperation(..)                      ,+    MountOperationK                         ,+    toMountOperation                        ,+    noMountOperation                        ,+++ -- * Methods+-- ** mountOperationGetAnonymous+    mountOperationGetAnonymous              ,+++-- ** mountOperationGetChoice+    mountOperationGetChoice                 ,+++-- ** mountOperationGetDomain+    mountOperationGetDomain                 ,+++-- ** mountOperationGetPassword+    mountOperationGetPassword               ,+++-- ** mountOperationGetPasswordSave+    mountOperationGetPasswordSave           ,+++-- ** mountOperationGetUsername+    mountOperationGetUsername               ,+++-- ** mountOperationNew+    mountOperationNew                       ,+++-- ** mountOperationReply+    mountOperationReply                     ,+++-- ** mountOperationSetAnonymous+    mountOperationSetAnonymous              ,+++-- ** mountOperationSetChoice+    mountOperationSetChoice                 ,+++-- ** mountOperationSetDomain+    mountOperationSetDomain                 ,+++-- ** mountOperationSetPassword+    mountOperationSetPassword               ,+++-- ** mountOperationSetPasswordSave+    mountOperationSetPasswordSave           ,+++-- ** mountOperationSetUsername+    mountOperationSetUsername               ,+++++ -- * Properties+-- ** Anonymous+    MountOperationAnonymousPropertyInfo     ,+    constructMountOperationAnonymous        ,+    getMountOperationAnonymous              ,+    setMountOperationAnonymous              ,+++-- ** Choice+    MountOperationChoicePropertyInfo        ,+    constructMountOperationChoice           ,+    getMountOperationChoice                 ,+    setMountOperationChoice                 ,+++-- ** Domain+    MountOperationDomainPropertyInfo        ,+    constructMountOperationDomain           ,+    getMountOperationDomain                 ,+    setMountOperationDomain                 ,+++-- ** Password+    MountOperationPasswordPropertyInfo      ,+    constructMountOperationPassword         ,+    getMountOperationPassword               ,+    setMountOperationPassword               ,+++-- ** PasswordSave+    MountOperationPasswordSavePropertyInfo  ,+    constructMountOperationPasswordSave     ,+    getMountOperationPasswordSave           ,+    setMountOperationPasswordSave           ,+++-- ** Username+    MountOperationUsernamePropertyInfo      ,+    constructMountOperationUsername         ,+    getMountOperationUsername               ,+    setMountOperationUsername               ,+++++ -- * Signals+-- ** Aborted+    MountOperationAbortedCallback           ,+    MountOperationAbortedCallbackC          ,+    MountOperationAbortedSignalInfo         ,+    afterMountOperationAborted              ,+    mkMountOperationAbortedCallback         ,+    mountOperationAbortedCallbackWrapper    ,+    mountOperationAbortedClosure            ,+    noMountOperationAbortedCallback         ,+    onMountOperationAborted                 ,+++-- ** AskPassword+    MountOperationAskPasswordCallback       ,+    MountOperationAskPasswordCallbackC      ,+    MountOperationAskPasswordSignalInfo     ,+    afterMountOperationAskPassword          ,+    mkMountOperationAskPasswordCallback     ,+    mountOperationAskPasswordCallbackWrapper,+    mountOperationAskPasswordClosure        ,+    noMountOperationAskPasswordCallback     ,+    onMountOperationAskPassword             ,+++-- ** AskQuestion+    MountOperationAskQuestionCallback       ,+    MountOperationAskQuestionCallbackC      ,+    MountOperationAskQuestionSignalInfo     ,+    afterMountOperationAskQuestion          ,+    mkMountOperationAskQuestionCallback     ,+    mountOperationAskQuestionCallbackWrapper,+    mountOperationAskQuestionClosure        ,+    noMountOperationAskQuestionCallback     ,+    onMountOperationAskQuestion             ,+++-- ** Reply+    MountOperationReplyCallback             ,+    MountOperationReplyCallbackC            ,+    MountOperationReplySignalInfo           ,+    afterMountOperationReply                ,+    mkMountOperationReplyCallback           ,+    mountOperationReplyCallbackWrapper      ,+    mountOperationReplyClosure              ,+    noMountOperationReplyCallback           ,+    onMountOperationReply                   ,+++-- ** ShowProcesses+    MountOperationShowProcessesCallback     ,+    MountOperationShowProcessesCallbackC    ,+    MountOperationShowProcessesSignalInfo   ,+    afterMountOperationShowProcesses        ,+    mkMountOperationShowProcessesCallback   ,+    mountOperationShowProcessesCallbackWrapper,+    mountOperationShowProcessesClosure      ,+    noMountOperationShowProcessesCallback   ,+    onMountOperationShowProcesses           ,+++-- ** ShowUnmountProgress+    MountOperationShowUnmountProgressCallback,+    MountOperationShowUnmountProgressCallbackC,+    MountOperationShowUnmountProgressSignalInfo,+    afterMountOperationShowUnmountProgress  ,+    mkMountOperationShowUnmountProgressCallback,+    mountOperationShowUnmountProgressCallbackWrapper,+    mountOperationShowUnmountProgressClosure,+    noMountOperationShowUnmountProgressCallback,+    onMountOperationShowUnmountProgress     ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype MountOperation = MountOperation (ForeignPtr MountOperation)+foreign import ccall "g_mount_operation_get_type"+    c_g_mount_operation_get_type :: IO GType++type instance ParentTypes MountOperation = MountOperationParentTypes+type MountOperationParentTypes = '[GObject.Object]++instance GObject MountOperation where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_mount_operation_get_type+    ++class GObject o => MountOperationK o+instance (GObject o, IsDescendantOf MountOperation o) => MountOperationK o++toMountOperation :: MountOperationK o => o -> IO MountOperation+toMountOperation = unsafeCastTo MountOperation++noMountOperation :: Maybe MountOperation+noMountOperation = Nothing++-- signal MountOperation::aborted+type MountOperationAbortedCallback =+    IO ()++noMountOperationAbortedCallback :: Maybe MountOperationAbortedCallback+noMountOperationAbortedCallback = Nothing++type MountOperationAbortedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkMountOperationAbortedCallback :: MountOperationAbortedCallbackC -> IO (FunPtr MountOperationAbortedCallbackC)++mountOperationAbortedClosure :: MountOperationAbortedCallback -> IO Closure+mountOperationAbortedClosure cb = newCClosure =<< mkMountOperationAbortedCallback wrapped+    where wrapped = mountOperationAbortedCallbackWrapper cb++mountOperationAbortedCallbackWrapper ::+    MountOperationAbortedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+mountOperationAbortedCallbackWrapper _cb _ _ = do+    _cb ++onMountOperationAborted :: (GObject a, MonadIO m) => a -> MountOperationAbortedCallback -> m SignalHandlerId+onMountOperationAborted obj cb = liftIO $ connectMountOperationAborted obj cb SignalConnectBefore+afterMountOperationAborted :: (GObject a, MonadIO m) => a -> MountOperationAbortedCallback -> m SignalHandlerId+afterMountOperationAborted obj cb = connectMountOperationAborted obj cb SignalConnectAfter++connectMountOperationAborted :: (GObject a, MonadIO m) =>+                                a -> MountOperationAbortedCallback -> SignalConnectMode -> m SignalHandlerId+connectMountOperationAborted obj cb after = liftIO $ do+    cb' <- mkMountOperationAbortedCallback (mountOperationAbortedCallbackWrapper cb)+    connectSignalFunPtr obj "aborted" cb' after++-- signal MountOperation::ask-password+type MountOperationAskPasswordCallback =+    T.Text ->+    T.Text ->+    T.Text ->+    [AskPasswordFlags] ->+    IO ()++noMountOperationAskPasswordCallback :: Maybe MountOperationAskPasswordCallback+noMountOperationAskPasswordCallback = Nothing++type MountOperationAskPasswordCallbackC =+    Ptr () ->                               -- object+    CString ->+    CString ->+    CString ->+    CUInt ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkMountOperationAskPasswordCallback :: MountOperationAskPasswordCallbackC -> IO (FunPtr MountOperationAskPasswordCallbackC)++mountOperationAskPasswordClosure :: MountOperationAskPasswordCallback -> IO Closure+mountOperationAskPasswordClosure cb = newCClosure =<< mkMountOperationAskPasswordCallback wrapped+    where wrapped = mountOperationAskPasswordCallbackWrapper cb++mountOperationAskPasswordCallbackWrapper ::+    MountOperationAskPasswordCallback ->+    Ptr () ->+    CString ->+    CString ->+    CString ->+    CUInt ->+    Ptr () ->+    IO ()+mountOperationAskPasswordCallbackWrapper _cb _ message default_user default_domain flags _ = do+    message' <- cstringToText message+    default_user' <- cstringToText default_user+    default_domain' <- cstringToText default_domain+    let flags' = wordToGFlags flags+    _cb  message' default_user' default_domain' flags'++onMountOperationAskPassword :: (GObject a, MonadIO m) => a -> MountOperationAskPasswordCallback -> m SignalHandlerId+onMountOperationAskPassword obj cb = liftIO $ connectMountOperationAskPassword obj cb SignalConnectBefore+afterMountOperationAskPassword :: (GObject a, MonadIO m) => a -> MountOperationAskPasswordCallback -> m SignalHandlerId+afterMountOperationAskPassword obj cb = connectMountOperationAskPassword obj cb SignalConnectAfter++connectMountOperationAskPassword :: (GObject a, MonadIO m) =>+                                    a -> MountOperationAskPasswordCallback -> SignalConnectMode -> m SignalHandlerId+connectMountOperationAskPassword obj cb after = liftIO $ do+    cb' <- mkMountOperationAskPasswordCallback (mountOperationAskPasswordCallbackWrapper cb)+    connectSignalFunPtr obj "ask-password" cb' after++-- signal MountOperation::ask-question+type MountOperationAskQuestionCallback =+    T.Text ->+    [T.Text] ->+    IO ()++noMountOperationAskQuestionCallback :: Maybe MountOperationAskQuestionCallback+noMountOperationAskQuestionCallback = Nothing++type MountOperationAskQuestionCallbackC =+    Ptr () ->                               -- object+    CString ->+    Ptr CString ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkMountOperationAskQuestionCallback :: MountOperationAskQuestionCallbackC -> IO (FunPtr MountOperationAskQuestionCallbackC)++mountOperationAskQuestionClosure :: MountOperationAskQuestionCallback -> IO Closure+mountOperationAskQuestionClosure cb = newCClosure =<< mkMountOperationAskQuestionCallback wrapped+    where wrapped = mountOperationAskQuestionCallbackWrapper cb++mountOperationAskQuestionCallbackWrapper ::+    MountOperationAskQuestionCallback ->+    Ptr () ->+    CString ->+    Ptr CString ->+    Ptr () ->+    IO ()+mountOperationAskQuestionCallbackWrapper _cb _ message choices _ = do+    message' <- cstringToText message+    choices' <- unpackZeroTerminatedUTF8CArray choices+    _cb  message' choices'++onMountOperationAskQuestion :: (GObject a, MonadIO m) => a -> MountOperationAskQuestionCallback -> m SignalHandlerId+onMountOperationAskQuestion obj cb = liftIO $ connectMountOperationAskQuestion obj cb SignalConnectBefore+afterMountOperationAskQuestion :: (GObject a, MonadIO m) => a -> MountOperationAskQuestionCallback -> m SignalHandlerId+afterMountOperationAskQuestion obj cb = connectMountOperationAskQuestion obj cb SignalConnectAfter++connectMountOperationAskQuestion :: (GObject a, MonadIO m) =>+                                    a -> MountOperationAskQuestionCallback -> SignalConnectMode -> m SignalHandlerId+connectMountOperationAskQuestion obj cb after = liftIO $ do+    cb' <- mkMountOperationAskQuestionCallback (mountOperationAskQuestionCallbackWrapper cb)+    connectSignalFunPtr obj "ask-question" cb' after++-- signal MountOperation::reply+type MountOperationReplyCallback =+    MountOperationResult ->+    IO ()++noMountOperationReplyCallback :: Maybe MountOperationReplyCallback+noMountOperationReplyCallback = Nothing++type MountOperationReplyCallbackC =+    Ptr () ->                               -- object+    CUInt ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkMountOperationReplyCallback :: MountOperationReplyCallbackC -> IO (FunPtr MountOperationReplyCallbackC)++mountOperationReplyClosure :: MountOperationReplyCallback -> IO Closure+mountOperationReplyClosure cb = newCClosure =<< mkMountOperationReplyCallback wrapped+    where wrapped = mountOperationReplyCallbackWrapper cb++mountOperationReplyCallbackWrapper ::+    MountOperationReplyCallback ->+    Ptr () ->+    CUInt ->+    Ptr () ->+    IO ()+mountOperationReplyCallbackWrapper _cb _ result_ _ = do+    let result_' = (toEnum . fromIntegral) result_+    _cb  result_'++onMountOperationReply :: (GObject a, MonadIO m) => a -> MountOperationReplyCallback -> m SignalHandlerId+onMountOperationReply obj cb = liftIO $ connectMountOperationReply obj cb SignalConnectBefore+afterMountOperationReply :: (GObject a, MonadIO m) => a -> MountOperationReplyCallback -> m SignalHandlerId+afterMountOperationReply obj cb = connectMountOperationReply obj cb SignalConnectAfter++connectMountOperationReply :: (GObject a, MonadIO m) =>+                              a -> MountOperationReplyCallback -> SignalConnectMode -> m SignalHandlerId+connectMountOperationReply obj cb after = liftIO $ do+    cb' <- mkMountOperationReplyCallback (mountOperationReplyCallbackWrapper cb)+    connectSignalFunPtr obj "reply" cb' after++-- signal MountOperation::show-processes+type MountOperationShowProcessesCallback =+    T.Text ->+    [Int32] ->+    [T.Text] ->+    IO ()++noMountOperationShowProcessesCallback :: Maybe MountOperationShowProcessesCallback+noMountOperationShowProcessesCallback = Nothing++type MountOperationShowProcessesCallbackC =+    Ptr () ->                               -- object+    CString ->+    Ptr (GArray Int32) ->+    Ptr CString ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkMountOperationShowProcessesCallback :: MountOperationShowProcessesCallbackC -> IO (FunPtr MountOperationShowProcessesCallbackC)++mountOperationShowProcessesClosure :: MountOperationShowProcessesCallback -> IO Closure+mountOperationShowProcessesClosure cb = newCClosure =<< mkMountOperationShowProcessesCallback wrapped+    where wrapped = mountOperationShowProcessesCallbackWrapper cb++mountOperationShowProcessesCallbackWrapper ::+    MountOperationShowProcessesCallback ->+    Ptr () ->+    CString ->+    Ptr (GArray Int32) ->+    Ptr CString ->+    Ptr () ->+    IO ()+mountOperationShowProcessesCallbackWrapper _cb _ message processes choices _ = do+    message' <- cstringToText message+    processes' <- unpackGArray processes+    choices' <- unpackZeroTerminatedUTF8CArray choices+    _cb  message' processes' choices'++onMountOperationShowProcesses :: (GObject a, MonadIO m) => a -> MountOperationShowProcessesCallback -> m SignalHandlerId+onMountOperationShowProcesses obj cb = liftIO $ connectMountOperationShowProcesses obj cb SignalConnectBefore+afterMountOperationShowProcesses :: (GObject a, MonadIO m) => a -> MountOperationShowProcessesCallback -> m SignalHandlerId+afterMountOperationShowProcesses obj cb = connectMountOperationShowProcesses obj cb SignalConnectAfter++connectMountOperationShowProcesses :: (GObject a, MonadIO m) =>+                                      a -> MountOperationShowProcessesCallback -> SignalConnectMode -> m SignalHandlerId+connectMountOperationShowProcesses obj cb after = liftIO $ do+    cb' <- mkMountOperationShowProcessesCallback (mountOperationShowProcessesCallbackWrapper cb)+    connectSignalFunPtr obj "show-processes" cb' after++-- signal MountOperation::show-unmount-progress+type MountOperationShowUnmountProgressCallback =+    T.Text ->+    Int64 ->+    Int64 ->+    IO ()++noMountOperationShowUnmountProgressCallback :: Maybe MountOperationShowUnmountProgressCallback+noMountOperationShowUnmountProgressCallback = Nothing++type MountOperationShowUnmountProgressCallbackC =+    Ptr () ->                               -- object+    CString ->+    Int64 ->+    Int64 ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkMountOperationShowUnmountProgressCallback :: MountOperationShowUnmountProgressCallbackC -> IO (FunPtr MountOperationShowUnmountProgressCallbackC)++mountOperationShowUnmountProgressClosure :: MountOperationShowUnmountProgressCallback -> IO Closure+mountOperationShowUnmountProgressClosure cb = newCClosure =<< mkMountOperationShowUnmountProgressCallback wrapped+    where wrapped = mountOperationShowUnmountProgressCallbackWrapper cb++mountOperationShowUnmountProgressCallbackWrapper ::+    MountOperationShowUnmountProgressCallback ->+    Ptr () ->+    CString ->+    Int64 ->+    Int64 ->+    Ptr () ->+    IO ()+mountOperationShowUnmountProgressCallbackWrapper _cb _ message time_left bytes_left _ = do+    message' <- cstringToText message+    _cb  message' time_left bytes_left++onMountOperationShowUnmountProgress :: (GObject a, MonadIO m) => a -> MountOperationShowUnmountProgressCallback -> m SignalHandlerId+onMountOperationShowUnmountProgress obj cb = liftIO $ connectMountOperationShowUnmountProgress obj cb SignalConnectBefore+afterMountOperationShowUnmountProgress :: (GObject a, MonadIO m) => a -> MountOperationShowUnmountProgressCallback -> m SignalHandlerId+afterMountOperationShowUnmountProgress obj cb = connectMountOperationShowUnmountProgress obj cb SignalConnectAfter++connectMountOperationShowUnmountProgress :: (GObject a, MonadIO m) =>+                                            a -> MountOperationShowUnmountProgressCallback -> SignalConnectMode -> m SignalHandlerId+connectMountOperationShowUnmountProgress obj cb after = liftIO $ do+    cb' <- mkMountOperationShowUnmountProgressCallback (mountOperationShowUnmountProgressCallbackWrapper cb)+    connectSignalFunPtr obj "show-unmount-progress" cb' after++-- VVV Prop "anonymous"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getMountOperationAnonymous :: (MonadIO m, MountOperationK o) => o -> m Bool+getMountOperationAnonymous obj = liftIO $ getObjectPropertyBool obj "anonymous"++setMountOperationAnonymous :: (MonadIO m, MountOperationK o) => o -> Bool -> m ()+setMountOperationAnonymous obj val = liftIO $ setObjectPropertyBool obj "anonymous" val++constructMountOperationAnonymous :: Bool -> IO ([Char], GValue)+constructMountOperationAnonymous val = constructObjectPropertyBool "anonymous" val++data MountOperationAnonymousPropertyInfo+instance AttrInfo MountOperationAnonymousPropertyInfo where+    type AttrAllowedOps MountOperationAnonymousPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MountOperationAnonymousPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint MountOperationAnonymousPropertyInfo = MountOperationK+    type AttrGetType MountOperationAnonymousPropertyInfo = Bool+    type AttrLabel MountOperationAnonymousPropertyInfo = "MountOperation::anonymous"+    attrGet _ = getMountOperationAnonymous+    attrSet _ = setMountOperationAnonymous+    attrConstruct _ = constructMountOperationAnonymous++-- VVV Prop "choice"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getMountOperationChoice :: (MonadIO m, MountOperationK o) => o -> m Int32+getMountOperationChoice obj = liftIO $ getObjectPropertyCInt obj "choice"++setMountOperationChoice :: (MonadIO m, MountOperationK o) => o -> Int32 -> m ()+setMountOperationChoice obj val = liftIO $ setObjectPropertyCInt obj "choice" val++constructMountOperationChoice :: Int32 -> IO ([Char], GValue)+constructMountOperationChoice val = constructObjectPropertyCInt "choice" val++data MountOperationChoicePropertyInfo+instance AttrInfo MountOperationChoicePropertyInfo where+    type AttrAllowedOps MountOperationChoicePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MountOperationChoicePropertyInfo = (~) Int32+    type AttrBaseTypeConstraint MountOperationChoicePropertyInfo = MountOperationK+    type AttrGetType MountOperationChoicePropertyInfo = Int32+    type AttrLabel MountOperationChoicePropertyInfo = "MountOperation::choice"+    attrGet _ = getMountOperationChoice+    attrSet _ = setMountOperationChoice+    attrConstruct _ = constructMountOperationChoice++-- VVV Prop "domain"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getMountOperationDomain :: (MonadIO m, MountOperationK o) => o -> m T.Text+getMountOperationDomain obj = liftIO $ getObjectPropertyString obj "domain"++setMountOperationDomain :: (MonadIO m, MountOperationK o) => o -> T.Text -> m ()+setMountOperationDomain obj val = liftIO $ setObjectPropertyString obj "domain" val++constructMountOperationDomain :: T.Text -> IO ([Char], GValue)+constructMountOperationDomain val = constructObjectPropertyString "domain" val++data MountOperationDomainPropertyInfo+instance AttrInfo MountOperationDomainPropertyInfo where+    type AttrAllowedOps MountOperationDomainPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MountOperationDomainPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint MountOperationDomainPropertyInfo = MountOperationK+    type AttrGetType MountOperationDomainPropertyInfo = T.Text+    type AttrLabel MountOperationDomainPropertyInfo = "MountOperation::domain"+    attrGet _ = getMountOperationDomain+    attrSet _ = setMountOperationDomain+    attrConstruct _ = constructMountOperationDomain++-- VVV Prop "password"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getMountOperationPassword :: (MonadIO m, MountOperationK o) => o -> m T.Text+getMountOperationPassword obj = liftIO $ getObjectPropertyString obj "password"++setMountOperationPassword :: (MonadIO m, MountOperationK o) => o -> T.Text -> m ()+setMountOperationPassword obj val = liftIO $ setObjectPropertyString obj "password" val++constructMountOperationPassword :: T.Text -> IO ([Char], GValue)+constructMountOperationPassword val = constructObjectPropertyString "password" val++data MountOperationPasswordPropertyInfo+instance AttrInfo MountOperationPasswordPropertyInfo where+    type AttrAllowedOps MountOperationPasswordPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MountOperationPasswordPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint MountOperationPasswordPropertyInfo = MountOperationK+    type AttrGetType MountOperationPasswordPropertyInfo = T.Text+    type AttrLabel MountOperationPasswordPropertyInfo = "MountOperation::password"+    attrGet _ = getMountOperationPassword+    attrSet _ = setMountOperationPassword+    attrConstruct _ = constructMountOperationPassword++-- VVV Prop "password-save"+   -- Type: TInterface "Gio" "PasswordSave"+   -- Flags: [PropertyReadable,PropertyWritable]++getMountOperationPasswordSave :: (MonadIO m, MountOperationK o) => o -> m PasswordSave+getMountOperationPasswordSave obj = liftIO $ getObjectPropertyEnum obj "password-save"++setMountOperationPasswordSave :: (MonadIO m, MountOperationK o) => o -> PasswordSave -> m ()+setMountOperationPasswordSave obj val = liftIO $ setObjectPropertyEnum obj "password-save" val++constructMountOperationPasswordSave :: PasswordSave -> IO ([Char], GValue)+constructMountOperationPasswordSave val = constructObjectPropertyEnum "password-save" val++data MountOperationPasswordSavePropertyInfo+instance AttrInfo MountOperationPasswordSavePropertyInfo where+    type AttrAllowedOps MountOperationPasswordSavePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MountOperationPasswordSavePropertyInfo = (~) PasswordSave+    type AttrBaseTypeConstraint MountOperationPasswordSavePropertyInfo = MountOperationK+    type AttrGetType MountOperationPasswordSavePropertyInfo = PasswordSave+    type AttrLabel MountOperationPasswordSavePropertyInfo = "MountOperation::password-save"+    attrGet _ = getMountOperationPasswordSave+    attrSet _ = setMountOperationPasswordSave+    attrConstruct _ = constructMountOperationPasswordSave++-- VVV Prop "username"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getMountOperationUsername :: (MonadIO m, MountOperationK o) => o -> m T.Text+getMountOperationUsername obj = liftIO $ getObjectPropertyString obj "username"++setMountOperationUsername :: (MonadIO m, MountOperationK o) => o -> T.Text -> m ()+setMountOperationUsername obj val = liftIO $ setObjectPropertyString obj "username" val++constructMountOperationUsername :: T.Text -> IO ([Char], GValue)+constructMountOperationUsername val = constructObjectPropertyString "username" val++data MountOperationUsernamePropertyInfo+instance AttrInfo MountOperationUsernamePropertyInfo where+    type AttrAllowedOps MountOperationUsernamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MountOperationUsernamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint MountOperationUsernamePropertyInfo = MountOperationK+    type AttrGetType MountOperationUsernamePropertyInfo = T.Text+    type AttrLabel MountOperationUsernamePropertyInfo = "MountOperation::username"+    attrGet _ = getMountOperationUsername+    attrSet _ = setMountOperationUsername+    attrConstruct _ = constructMountOperationUsername++type instance AttributeList MountOperation = MountOperationAttributeList+type MountOperationAttributeList = ('[ '("anonymous", MountOperationAnonymousPropertyInfo), '("choice", MountOperationChoicePropertyInfo), '("domain", MountOperationDomainPropertyInfo), '("password", MountOperationPasswordPropertyInfo), '("password-save", MountOperationPasswordSavePropertyInfo), '("username", MountOperationUsernamePropertyInfo)] :: [(Symbol, *)])++data MountOperationAbortedSignalInfo+instance SignalInfo MountOperationAbortedSignalInfo where+    type HaskellCallbackType MountOperationAbortedSignalInfo = MountOperationAbortedCallback+    connectSignal _ = connectMountOperationAborted++data MountOperationAskPasswordSignalInfo+instance SignalInfo MountOperationAskPasswordSignalInfo where+    type HaskellCallbackType MountOperationAskPasswordSignalInfo = MountOperationAskPasswordCallback+    connectSignal _ = connectMountOperationAskPassword++data MountOperationAskQuestionSignalInfo+instance SignalInfo MountOperationAskQuestionSignalInfo where+    type HaskellCallbackType MountOperationAskQuestionSignalInfo = MountOperationAskQuestionCallback+    connectSignal _ = connectMountOperationAskQuestion++data MountOperationReplySignalInfo+instance SignalInfo MountOperationReplySignalInfo where+    type HaskellCallbackType MountOperationReplySignalInfo = MountOperationReplyCallback+    connectSignal _ = connectMountOperationReply++data MountOperationShowProcessesSignalInfo+instance SignalInfo MountOperationShowProcessesSignalInfo where+    type HaskellCallbackType MountOperationShowProcessesSignalInfo = MountOperationShowProcessesCallback+    connectSignal _ = connectMountOperationShowProcesses++data MountOperationShowUnmountProgressSignalInfo+instance SignalInfo MountOperationShowUnmountProgressSignalInfo where+    type HaskellCallbackType MountOperationShowUnmountProgressSignalInfo = MountOperationShowUnmountProgressCallback+    connectSignal _ = connectMountOperationShowUnmountProgress++type instance SignalList MountOperation = MountOperationSignalList+type MountOperationSignalList = ('[ '("aborted", MountOperationAbortedSignalInfo), '("ask-password", MountOperationAskPasswordSignalInfo), '("ask-question", MountOperationAskQuestionSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("reply", MountOperationReplySignalInfo), '("show-processes", MountOperationShowProcessesSignalInfo), '("show-unmount-progress", MountOperationShowUnmountProgressSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method MountOperation::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gio" "MountOperation"+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_operation_new" g_mount_operation_new :: +    IO (Ptr MountOperation)+++mountOperationNew ::+    (MonadIO m) =>+    m MountOperation+mountOperationNew  = liftIO $ do+    result <- g_mount_operation_new+    checkUnexpectedReturnNULL "g_mount_operation_new" result+    result' <- (wrapObject MountOperation) result+    return result'++-- method MountOperation::get_anonymous+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_operation_get_anonymous" g_mount_operation_get_anonymous :: +    Ptr MountOperation ->                   -- _obj : TInterface "Gio" "MountOperation"+    IO CInt+++mountOperationGetAnonymous ::+    (MonadIO m, MountOperationK a) =>+    a ->                                    -- _obj+    m Bool+mountOperationGetAnonymous _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_mount_operation_get_anonymous _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method MountOperation::get_choice+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_operation_get_choice" g_mount_operation_get_choice :: +    Ptr MountOperation ->                   -- _obj : TInterface "Gio" "MountOperation"+    IO Int32+++mountOperationGetChoice ::+    (MonadIO m, MountOperationK a) =>+    a ->                                    -- _obj+    m Int32+mountOperationGetChoice _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_mount_operation_get_choice _obj'+    touchManagedPtr _obj+    return result++-- method MountOperation::get_domain+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_operation_get_domain" g_mount_operation_get_domain :: +    Ptr MountOperation ->                   -- _obj : TInterface "Gio" "MountOperation"+    IO CString+++mountOperationGetDomain ::+    (MonadIO m, MountOperationK a) =>+    a ->                                    -- _obj+    m T.Text+mountOperationGetDomain _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_mount_operation_get_domain _obj'+    checkUnexpectedReturnNULL "g_mount_operation_get_domain" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method MountOperation::get_password+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_operation_get_password" g_mount_operation_get_password :: +    Ptr MountOperation ->                   -- _obj : TInterface "Gio" "MountOperation"+    IO CString+++mountOperationGetPassword ::+    (MonadIO m, MountOperationK a) =>+    a ->                                    -- _obj+    m T.Text+mountOperationGetPassword _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_mount_operation_get_password _obj'+    checkUnexpectedReturnNULL "g_mount_operation_get_password" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method MountOperation::get_password_save+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "PasswordSave"+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_operation_get_password_save" g_mount_operation_get_password_save :: +    Ptr MountOperation ->                   -- _obj : TInterface "Gio" "MountOperation"+    IO CUInt+++mountOperationGetPasswordSave ::+    (MonadIO m, MountOperationK a) =>+    a ->                                    -- _obj+    m PasswordSave+mountOperationGetPasswordSave _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_mount_operation_get_password_save _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method MountOperation::get_username+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_operation_get_username" g_mount_operation_get_username :: +    Ptr MountOperation ->                   -- _obj : TInterface "Gio" "MountOperation"+    IO CString+++mountOperationGetUsername ::+    (MonadIO m, MountOperationK a) =>+    a ->                                    -- _obj+    m T.Text+mountOperationGetUsername _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_mount_operation_get_username _obj'+    checkUnexpectedReturnNULL "g_mount_operation_get_username" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method MountOperation::reply+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "MountOperationResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "MountOperationResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_operation_reply" g_mount_operation_reply :: +    Ptr MountOperation ->                   -- _obj : TInterface "Gio" "MountOperation"+    CUInt ->                                -- result : TInterface "Gio" "MountOperationResult"+    IO ()+++mountOperationReply ::+    (MonadIO m, MountOperationK a) =>+    a ->                                    -- _obj+    MountOperationResult ->                 -- result+    m ()+mountOperationReply _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = (fromIntegral . fromEnum) result_+    g_mount_operation_reply _obj' result_'+    touchManagedPtr _obj+    return ()++-- method MountOperation::set_anonymous+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "anonymous", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "anonymous", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_operation_set_anonymous" g_mount_operation_set_anonymous :: +    Ptr MountOperation ->                   -- _obj : TInterface "Gio" "MountOperation"+    CInt ->                                 -- anonymous : TBasicType TBoolean+    IO ()+++mountOperationSetAnonymous ::+    (MonadIO m, MountOperationK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- anonymous+    m ()+mountOperationSetAnonymous _obj anonymous = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let anonymous' = (fromIntegral . fromEnum) anonymous+    g_mount_operation_set_anonymous _obj' anonymous'+    touchManagedPtr _obj+    return ()++-- method MountOperation::set_choice+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "choice", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "choice", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_operation_set_choice" g_mount_operation_set_choice :: +    Ptr MountOperation ->                   -- _obj : TInterface "Gio" "MountOperation"+    Int32 ->                                -- choice : TBasicType TInt32+    IO ()+++mountOperationSetChoice ::+    (MonadIO m, MountOperationK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- choice+    m ()+mountOperationSetChoice _obj choice = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_mount_operation_set_choice _obj' choice+    touchManagedPtr _obj+    return ()++-- method MountOperation::set_domain+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "domain", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "domain", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_operation_set_domain" g_mount_operation_set_domain :: +    Ptr MountOperation ->                   -- _obj : TInterface "Gio" "MountOperation"+    CString ->                              -- domain : TBasicType TUTF8+    IO ()+++mountOperationSetDomain ::+    (MonadIO m, MountOperationK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- domain+    m ()+mountOperationSetDomain _obj domain = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    domain' <- textToCString domain+    g_mount_operation_set_domain _obj' domain'+    touchManagedPtr _obj+    freeMem domain'+    return ()++-- method MountOperation::set_password+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "password", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "password", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_operation_set_password" g_mount_operation_set_password :: +    Ptr MountOperation ->                   -- _obj : TInterface "Gio" "MountOperation"+    CString ->                              -- password : TBasicType TUTF8+    IO ()+++mountOperationSetPassword ::+    (MonadIO m, MountOperationK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- password+    m ()+mountOperationSetPassword _obj password = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    password' <- textToCString password+    g_mount_operation_set_password _obj' password'+    touchManagedPtr _obj+    freeMem password'+    return ()++-- method MountOperation::set_password_save+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "save", argType = TInterface "Gio" "PasswordSave", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "save", argType = TInterface "Gio" "PasswordSave", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_operation_set_password_save" g_mount_operation_set_password_save :: +    Ptr MountOperation ->                   -- _obj : TInterface "Gio" "MountOperation"+    CUInt ->                                -- save : TInterface "Gio" "PasswordSave"+    IO ()+++mountOperationSetPasswordSave ::+    (MonadIO m, MountOperationK a) =>+    a ->                                    -- _obj+    PasswordSave ->                         -- save+    m ()+mountOperationSetPasswordSave _obj save = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let save' = (fromIntegral . fromEnum) save+    g_mount_operation_set_password_save _obj' save'+    touchManagedPtr _obj+    return ()++-- method MountOperation::set_username+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "username", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "username", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_mount_operation_set_username" g_mount_operation_set_username :: +    Ptr MountOperation ->                   -- _obj : TInterface "Gio" "MountOperation"+    CString ->                              -- username : TBasicType TUTF8+    IO ()+++mountOperationSetUsername ::+    (MonadIO m, MountOperationK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- username+    m ()+mountOperationSetUsername _obj username = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    username' <- textToCString username+    g_mount_operation_set_username _obj' username'+    touchManagedPtr _obj+    freeMem username'+    return ()++
+ GI/Gio/Objects/MountOperation.hs-boot view
@@ -0,0 +1,25 @@+module GI.Gio.Objects.MountOperation where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype MountOperation = MountOperation (ForeignPtr MountOperation)+instance GObject MountOperation where+class GObject o => MountOperationK o+instance (GObject o, IsDescendantOf MountOperation o) => MountOperationK o+data MountOperationAnonymousPropertyInfo+data MountOperationChoicePropertyInfo+data MountOperationDomainPropertyInfo+data MountOperationPasswordPropertyInfo+data MountOperationPasswordSavePropertyInfo+data MountOperationUsernamePropertyInfo+data MountOperationAbortedSignalInfo+data MountOperationAskPasswordSignalInfo+data MountOperationAskQuestionSignalInfo+data MountOperationReplySignalInfo+data MountOperationShowProcessesSignalInfo+data MountOperationShowUnmountProgressSignalInfo
+ GI/Gio/Objects/NativeVolumeMonitor.hs view
@@ -0,0 +1,58 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.NativeVolumeMonitor+    ( ++-- * Exported types+    NativeVolumeMonitor(..)                 ,+    NativeVolumeMonitorK                    ,+    toNativeVolumeMonitor                   ,+    noNativeVolumeMonitor                   ,+++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype NativeVolumeMonitor = NativeVolumeMonitor (ForeignPtr NativeVolumeMonitor)+foreign import ccall "g_native_volume_monitor_get_type"+    c_g_native_volume_monitor_get_type :: IO GType++type instance ParentTypes NativeVolumeMonitor = NativeVolumeMonitorParentTypes+type NativeVolumeMonitorParentTypes = '[VolumeMonitor, GObject.Object]++instance GObject NativeVolumeMonitor where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_native_volume_monitor_get_type+    ++class GObject o => NativeVolumeMonitorK o+instance (GObject o, IsDescendantOf NativeVolumeMonitor o) => NativeVolumeMonitorK o++toNativeVolumeMonitor :: NativeVolumeMonitorK o => o -> IO NativeVolumeMonitor+toNativeVolumeMonitor = unsafeCastTo NativeVolumeMonitor++noNativeVolumeMonitor :: Maybe NativeVolumeMonitor+noNativeVolumeMonitor = Nothing++type instance AttributeList NativeVolumeMonitor = NativeVolumeMonitorAttributeList+type NativeVolumeMonitorAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList NativeVolumeMonitor = NativeVolumeMonitorSignalList+type NativeVolumeMonitorSignalList = ('[ '("drive-changed", VolumeMonitorDriveChangedSignalInfo), '("drive-connected", VolumeMonitorDriveConnectedSignalInfo), '("drive-disconnected", VolumeMonitorDriveDisconnectedSignalInfo), '("drive-eject-button", VolumeMonitorDriveEjectButtonSignalInfo), '("drive-stop-button", VolumeMonitorDriveStopButtonSignalInfo), '("mount-added", VolumeMonitorMountAddedSignalInfo), '("mount-changed", VolumeMonitorMountChangedSignalInfo), '("mount-pre-unmount", VolumeMonitorMountPreUnmountSignalInfo), '("mount-removed", VolumeMonitorMountRemovedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("volume-added", VolumeMonitorVolumeAddedSignalInfo), '("volume-changed", VolumeMonitorVolumeChangedSignalInfo), '("volume-removed", VolumeMonitorVolumeRemovedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gio/Objects/NativeVolumeMonitor.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Objects.NativeVolumeMonitor where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype NativeVolumeMonitor = NativeVolumeMonitor (ForeignPtr NativeVolumeMonitor)+instance GObject NativeVolumeMonitor where+class GObject o => NativeVolumeMonitorK o+instance (GObject o, IsDescendantOf NativeVolumeMonitor o) => NativeVolumeMonitorK o
+ GI/Gio/Objects/NetworkAddress.hs view
@@ -0,0 +1,367 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.NetworkAddress+    ( ++-- * Exported types+    NetworkAddress(..)                      ,+    NetworkAddressK                         ,+    toNetworkAddress                        ,+    noNetworkAddress                        ,+++ -- * Methods+-- ** networkAddressGetHostname+    networkAddressGetHostname               ,+++-- ** networkAddressGetPort+    networkAddressGetPort                   ,+++-- ** networkAddressGetScheme+    networkAddressGetScheme                 ,+++-- ** networkAddressNew+    networkAddressNew                       ,+++-- ** networkAddressNewLoopback+    networkAddressNewLoopback               ,+++-- ** networkAddressParse+    networkAddressParse                     ,+++-- ** networkAddressParseUri+    networkAddressParseUri                  ,+++++ -- * Properties+-- ** Hostname+    NetworkAddressHostnamePropertyInfo      ,+    constructNetworkAddressHostname         ,+    getNetworkAddressHostname               ,+++-- ** Port+    NetworkAddressPortPropertyInfo          ,+    constructNetworkAddressPort             ,+    getNetworkAddressPort                   ,+++-- ** Scheme+    NetworkAddressSchemePropertyInfo        ,+    constructNetworkAddressScheme           ,+    getNetworkAddressScheme                 ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype NetworkAddress = NetworkAddress (ForeignPtr NetworkAddress)+foreign import ccall "g_network_address_get_type"+    c_g_network_address_get_type :: IO GType++type instance ParentTypes NetworkAddress = NetworkAddressParentTypes+type NetworkAddressParentTypes = '[GObject.Object, SocketConnectable]++instance GObject NetworkAddress where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_network_address_get_type+    ++class GObject o => NetworkAddressK o+instance (GObject o, IsDescendantOf NetworkAddress o) => NetworkAddressK o++toNetworkAddress :: NetworkAddressK o => o -> IO NetworkAddress+toNetworkAddress = unsafeCastTo NetworkAddress++noNetworkAddress :: Maybe NetworkAddress+noNetworkAddress = Nothing++-- VVV Prop "hostname"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getNetworkAddressHostname :: (MonadIO m, NetworkAddressK o) => o -> m T.Text+getNetworkAddressHostname obj = liftIO $ getObjectPropertyString obj "hostname"++constructNetworkAddressHostname :: T.Text -> IO ([Char], GValue)+constructNetworkAddressHostname val = constructObjectPropertyString "hostname" val++data NetworkAddressHostnamePropertyInfo+instance AttrInfo NetworkAddressHostnamePropertyInfo where+    type AttrAllowedOps NetworkAddressHostnamePropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint NetworkAddressHostnamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint NetworkAddressHostnamePropertyInfo = NetworkAddressK+    type AttrGetType NetworkAddressHostnamePropertyInfo = T.Text+    type AttrLabel NetworkAddressHostnamePropertyInfo = "NetworkAddress::hostname"+    attrGet _ = getNetworkAddressHostname+    attrSet _ = undefined+    attrConstruct _ = constructNetworkAddressHostname++-- VVV Prop "port"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getNetworkAddressPort :: (MonadIO m, NetworkAddressK o) => o -> m Word32+getNetworkAddressPort obj = liftIO $ getObjectPropertyCUInt obj "port"++constructNetworkAddressPort :: Word32 -> IO ([Char], GValue)+constructNetworkAddressPort val = constructObjectPropertyCUInt "port" val++data NetworkAddressPortPropertyInfo+instance AttrInfo NetworkAddressPortPropertyInfo where+    type AttrAllowedOps NetworkAddressPortPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint NetworkAddressPortPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint NetworkAddressPortPropertyInfo = NetworkAddressK+    type AttrGetType NetworkAddressPortPropertyInfo = Word32+    type AttrLabel NetworkAddressPortPropertyInfo = "NetworkAddress::port"+    attrGet _ = getNetworkAddressPort+    attrSet _ = undefined+    attrConstruct _ = constructNetworkAddressPort++-- VVV Prop "scheme"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getNetworkAddressScheme :: (MonadIO m, NetworkAddressK o) => o -> m T.Text+getNetworkAddressScheme obj = liftIO $ getObjectPropertyString obj "scheme"++constructNetworkAddressScheme :: T.Text -> IO ([Char], GValue)+constructNetworkAddressScheme val = constructObjectPropertyString "scheme" val++data NetworkAddressSchemePropertyInfo+instance AttrInfo NetworkAddressSchemePropertyInfo where+    type AttrAllowedOps NetworkAddressSchemePropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint NetworkAddressSchemePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint NetworkAddressSchemePropertyInfo = NetworkAddressK+    type AttrGetType NetworkAddressSchemePropertyInfo = T.Text+    type AttrLabel NetworkAddressSchemePropertyInfo = "NetworkAddress::scheme"+    attrGet _ = getNetworkAddressScheme+    attrSet _ = undefined+    attrConstruct _ = constructNetworkAddressScheme++type instance AttributeList NetworkAddress = NetworkAddressAttributeList+type NetworkAddressAttributeList = ('[ '("hostname", NetworkAddressHostnamePropertyInfo), '("port", NetworkAddressPortPropertyInfo), '("scheme", NetworkAddressSchemePropertyInfo)] :: [(Symbol, *)])++type instance SignalList NetworkAddress = NetworkAddressSignalList+type NetworkAddressSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method NetworkAddress::new+-- method type : Constructor+-- Args : [Arg {argName = "hostname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "port", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "hostname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "port", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "NetworkAddress"+-- throws : False+-- Skip return : False++foreign import ccall "g_network_address_new" g_network_address_new :: +    CString ->                              -- hostname : TBasicType TUTF8+    Word16 ->                               -- port : TBasicType TUInt16+    IO (Ptr NetworkAddress)+++networkAddressNew ::+    (MonadIO m) =>+    T.Text ->                               -- hostname+    Word16 ->                               -- port+    m NetworkAddress+networkAddressNew hostname port = liftIO $ do+    hostname' <- textToCString hostname+    result <- g_network_address_new hostname' port+    checkUnexpectedReturnNULL "g_network_address_new" result+    result' <- (wrapObject NetworkAddress) result+    freeMem hostname'+    return result'++-- method NetworkAddress::new_loopback+-- method type : Constructor+-- Args : [Arg {argName = "port", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "port", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "NetworkAddress"+-- throws : False+-- Skip return : False++foreign import ccall "g_network_address_new_loopback" g_network_address_new_loopback :: +    Word16 ->                               -- port : TBasicType TUInt16+    IO (Ptr NetworkAddress)+++networkAddressNewLoopback ::+    (MonadIO m) =>+    Word16 ->                               -- port+    m NetworkAddress+networkAddressNewLoopback port = liftIO $ do+    result <- g_network_address_new_loopback port+    checkUnexpectedReturnNULL "g_network_address_new_loopback" result+    result' <- (wrapObject NetworkAddress) result+    return result'++-- method NetworkAddress::get_hostname+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "NetworkAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "NetworkAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_network_address_get_hostname" g_network_address_get_hostname :: +    Ptr NetworkAddress ->                   -- _obj : TInterface "Gio" "NetworkAddress"+    IO CString+++networkAddressGetHostname ::+    (MonadIO m, NetworkAddressK a) =>+    a ->                                    -- _obj+    m T.Text+networkAddressGetHostname _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_network_address_get_hostname _obj'+    checkUnexpectedReturnNULL "g_network_address_get_hostname" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method NetworkAddress::get_port+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "NetworkAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "NetworkAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt16+-- throws : False+-- Skip return : False++foreign import ccall "g_network_address_get_port" g_network_address_get_port :: +    Ptr NetworkAddress ->                   -- _obj : TInterface "Gio" "NetworkAddress"+    IO Word16+++networkAddressGetPort ::+    (MonadIO m, NetworkAddressK a) =>+    a ->                                    -- _obj+    m Word16+networkAddressGetPort _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_network_address_get_port _obj'+    touchManagedPtr _obj+    return result++-- method NetworkAddress::get_scheme+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "NetworkAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "NetworkAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_network_address_get_scheme" g_network_address_get_scheme :: +    Ptr NetworkAddress ->                   -- _obj : TInterface "Gio" "NetworkAddress"+    IO CString+++networkAddressGetScheme ::+    (MonadIO m, NetworkAddressK a) =>+    a ->                                    -- _obj+    m T.Text+networkAddressGetScheme _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_network_address_get_scheme _obj'+    checkUnexpectedReturnNULL "g_network_address_get_scheme" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method NetworkAddress::parse+-- method type : MemberFunction+-- Args : [Arg {argName = "host_and_port", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "default_port", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "host_and_port", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "default_port", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "NetworkAddress"+-- throws : True+-- Skip return : False++foreign import ccall "g_network_address_parse" g_network_address_parse :: +    CString ->                              -- host_and_port : TBasicType TUTF8+    Word16 ->                               -- default_port : TBasicType TUInt16+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr NetworkAddress)+++networkAddressParse ::+    (MonadIO m) =>+    T.Text ->                               -- host_and_port+    Word16 ->                               -- default_port+    m NetworkAddress+networkAddressParse host_and_port default_port = liftIO $ do+    host_and_port' <- textToCString host_and_port+    onException (do+        result <- propagateGError $ g_network_address_parse host_and_port' default_port+        checkUnexpectedReturnNULL "g_network_address_parse" result+        result' <- (wrapObject NetworkAddress) result+        freeMem host_and_port'+        return result'+     ) (do+        freeMem host_and_port'+     )++-- method NetworkAddress::parse_uri+-- method type : MemberFunction+-- Args : [Arg {argName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "default_port", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "default_port", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "NetworkAddress"+-- throws : True+-- Skip return : False++foreign import ccall "g_network_address_parse_uri" g_network_address_parse_uri :: +    CString ->                              -- uri : TBasicType TUTF8+    Word16 ->                               -- default_port : TBasicType TUInt16+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr NetworkAddress)+++networkAddressParseUri ::+    (MonadIO m) =>+    T.Text ->                               -- uri+    Word16 ->                               -- default_port+    m NetworkAddress+networkAddressParseUri uri default_port = liftIO $ do+    uri' <- textToCString uri+    onException (do+        result <- propagateGError $ g_network_address_parse_uri uri' default_port+        checkUnexpectedReturnNULL "g_network_address_parse_uri" result+        result' <- (wrapObject NetworkAddress) result+        freeMem uri'+        return result'+     ) (do+        freeMem uri'+     )++
+ GI/Gio/Objects/NetworkAddress.hs-boot view
@@ -0,0 +1,16 @@+module GI.Gio.Objects.NetworkAddress where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype NetworkAddress = NetworkAddress (ForeignPtr NetworkAddress)+instance GObject NetworkAddress where+class GObject o => NetworkAddressK o+instance (GObject o, IsDescendantOf NetworkAddress o) => NetworkAddressK o+data NetworkAddressHostnamePropertyInfo+data NetworkAddressPortPropertyInfo+data NetworkAddressSchemePropertyInfo
+ GI/Gio/Objects/NetworkService.hs view
@@ -0,0 +1,366 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.NetworkService+    ( ++-- * Exported types+    NetworkService(..)                      ,+    NetworkServiceK                         ,+    toNetworkService                        ,+    noNetworkService                        ,+++ -- * Methods+-- ** networkServiceGetDomain+    networkServiceGetDomain                 ,+++-- ** networkServiceGetProtocol+    networkServiceGetProtocol               ,+++-- ** networkServiceGetScheme+    networkServiceGetScheme                 ,+++-- ** networkServiceGetService+    networkServiceGetService                ,+++-- ** networkServiceNew+    networkServiceNew                       ,+++-- ** networkServiceSetScheme+    networkServiceSetScheme                 ,+++++ -- * Properties+-- ** Domain+    NetworkServiceDomainPropertyInfo        ,+    constructNetworkServiceDomain           ,+    getNetworkServiceDomain                 ,+++-- ** Protocol+    NetworkServiceProtocolPropertyInfo      ,+    constructNetworkServiceProtocol         ,+    getNetworkServiceProtocol               ,+++-- ** Scheme+    NetworkServiceSchemePropertyInfo        ,+    constructNetworkServiceScheme           ,+    getNetworkServiceScheme                 ,+    setNetworkServiceScheme                 ,+++-- ** Service+    NetworkServiceServicePropertyInfo       ,+    constructNetworkServiceService          ,+    getNetworkServiceService                ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype NetworkService = NetworkService (ForeignPtr NetworkService)+foreign import ccall "g_network_service_get_type"+    c_g_network_service_get_type :: IO GType++type instance ParentTypes NetworkService = NetworkServiceParentTypes+type NetworkServiceParentTypes = '[GObject.Object, SocketConnectable]++instance GObject NetworkService where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_network_service_get_type+    ++class GObject o => NetworkServiceK o+instance (GObject o, IsDescendantOf NetworkService o) => NetworkServiceK o++toNetworkService :: NetworkServiceK o => o -> IO NetworkService+toNetworkService = unsafeCastTo NetworkService++noNetworkService :: Maybe NetworkService+noNetworkService = Nothing++-- VVV Prop "domain"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getNetworkServiceDomain :: (MonadIO m, NetworkServiceK o) => o -> m T.Text+getNetworkServiceDomain obj = liftIO $ getObjectPropertyString obj "domain"++constructNetworkServiceDomain :: T.Text -> IO ([Char], GValue)+constructNetworkServiceDomain val = constructObjectPropertyString "domain" val++data NetworkServiceDomainPropertyInfo+instance AttrInfo NetworkServiceDomainPropertyInfo where+    type AttrAllowedOps NetworkServiceDomainPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint NetworkServiceDomainPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint NetworkServiceDomainPropertyInfo = NetworkServiceK+    type AttrGetType NetworkServiceDomainPropertyInfo = T.Text+    type AttrLabel NetworkServiceDomainPropertyInfo = "NetworkService::domain"+    attrGet _ = getNetworkServiceDomain+    attrSet _ = undefined+    attrConstruct _ = constructNetworkServiceDomain++-- VVV Prop "protocol"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getNetworkServiceProtocol :: (MonadIO m, NetworkServiceK o) => o -> m T.Text+getNetworkServiceProtocol obj = liftIO $ getObjectPropertyString obj "protocol"++constructNetworkServiceProtocol :: T.Text -> IO ([Char], GValue)+constructNetworkServiceProtocol val = constructObjectPropertyString "protocol" val++data NetworkServiceProtocolPropertyInfo+instance AttrInfo NetworkServiceProtocolPropertyInfo where+    type AttrAllowedOps NetworkServiceProtocolPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint NetworkServiceProtocolPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint NetworkServiceProtocolPropertyInfo = NetworkServiceK+    type AttrGetType NetworkServiceProtocolPropertyInfo = T.Text+    type AttrLabel NetworkServiceProtocolPropertyInfo = "NetworkService::protocol"+    attrGet _ = getNetworkServiceProtocol+    attrSet _ = undefined+    attrConstruct _ = constructNetworkServiceProtocol++-- VVV Prop "scheme"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getNetworkServiceScheme :: (MonadIO m, NetworkServiceK o) => o -> m T.Text+getNetworkServiceScheme obj = liftIO $ getObjectPropertyString obj "scheme"++setNetworkServiceScheme :: (MonadIO m, NetworkServiceK o) => o -> T.Text -> m ()+setNetworkServiceScheme obj val = liftIO $ setObjectPropertyString obj "scheme" val++constructNetworkServiceScheme :: T.Text -> IO ([Char], GValue)+constructNetworkServiceScheme val = constructObjectPropertyString "scheme" val++data NetworkServiceSchemePropertyInfo+instance AttrInfo NetworkServiceSchemePropertyInfo where+    type AttrAllowedOps NetworkServiceSchemePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint NetworkServiceSchemePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint NetworkServiceSchemePropertyInfo = NetworkServiceK+    type AttrGetType NetworkServiceSchemePropertyInfo = T.Text+    type AttrLabel NetworkServiceSchemePropertyInfo = "NetworkService::scheme"+    attrGet _ = getNetworkServiceScheme+    attrSet _ = setNetworkServiceScheme+    attrConstruct _ = constructNetworkServiceScheme++-- VVV Prop "service"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getNetworkServiceService :: (MonadIO m, NetworkServiceK o) => o -> m T.Text+getNetworkServiceService obj = liftIO $ getObjectPropertyString obj "service"++constructNetworkServiceService :: T.Text -> IO ([Char], GValue)+constructNetworkServiceService val = constructObjectPropertyString "service" val++data NetworkServiceServicePropertyInfo+instance AttrInfo NetworkServiceServicePropertyInfo where+    type AttrAllowedOps NetworkServiceServicePropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint NetworkServiceServicePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint NetworkServiceServicePropertyInfo = NetworkServiceK+    type AttrGetType NetworkServiceServicePropertyInfo = T.Text+    type AttrLabel NetworkServiceServicePropertyInfo = "NetworkService::service"+    attrGet _ = getNetworkServiceService+    attrSet _ = undefined+    attrConstruct _ = constructNetworkServiceService++type instance AttributeList NetworkService = NetworkServiceAttributeList+type NetworkServiceAttributeList = ('[ '("domain", NetworkServiceDomainPropertyInfo), '("protocol", NetworkServiceProtocolPropertyInfo), '("scheme", NetworkServiceSchemePropertyInfo), '("service", NetworkServiceServicePropertyInfo)] :: [(Symbol, *)])++type instance SignalList NetworkService = NetworkServiceSignalList+type NetworkServiceSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method NetworkService::new+-- method type : Constructor+-- Args : [Arg {argName = "service", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "protocol", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "domain", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "service", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "protocol", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "domain", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "NetworkService"+-- throws : False+-- Skip return : False++foreign import ccall "g_network_service_new" g_network_service_new :: +    CString ->                              -- service : TBasicType TUTF8+    CString ->                              -- protocol : TBasicType TUTF8+    CString ->                              -- domain : TBasicType TUTF8+    IO (Ptr NetworkService)+++networkServiceNew ::+    (MonadIO m) =>+    T.Text ->                               -- service+    T.Text ->                               -- protocol+    T.Text ->                               -- domain+    m NetworkService+networkServiceNew service protocol domain = liftIO $ do+    service' <- textToCString service+    protocol' <- textToCString protocol+    domain' <- textToCString domain+    result <- g_network_service_new service' protocol' domain'+    checkUnexpectedReturnNULL "g_network_service_new" result+    result' <- (wrapObject NetworkService) result+    freeMem service'+    freeMem protocol'+    freeMem domain'+    return result'++-- method NetworkService::get_domain+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "NetworkService", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "NetworkService", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_network_service_get_domain" g_network_service_get_domain :: +    Ptr NetworkService ->                   -- _obj : TInterface "Gio" "NetworkService"+    IO CString+++networkServiceGetDomain ::+    (MonadIO m, NetworkServiceK a) =>+    a ->                                    -- _obj+    m T.Text+networkServiceGetDomain _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_network_service_get_domain _obj'+    checkUnexpectedReturnNULL "g_network_service_get_domain" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method NetworkService::get_protocol+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "NetworkService", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "NetworkService", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_network_service_get_protocol" g_network_service_get_protocol :: +    Ptr NetworkService ->                   -- _obj : TInterface "Gio" "NetworkService"+    IO CString+++networkServiceGetProtocol ::+    (MonadIO m, NetworkServiceK a) =>+    a ->                                    -- _obj+    m T.Text+networkServiceGetProtocol _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_network_service_get_protocol _obj'+    checkUnexpectedReturnNULL "g_network_service_get_protocol" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method NetworkService::get_scheme+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "NetworkService", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "NetworkService", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_network_service_get_scheme" g_network_service_get_scheme :: +    Ptr NetworkService ->                   -- _obj : TInterface "Gio" "NetworkService"+    IO CString+++networkServiceGetScheme ::+    (MonadIO m, NetworkServiceK a) =>+    a ->                                    -- _obj+    m T.Text+networkServiceGetScheme _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_network_service_get_scheme _obj'+    checkUnexpectedReturnNULL "g_network_service_get_scheme" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method NetworkService::get_service+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "NetworkService", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "NetworkService", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_network_service_get_service" g_network_service_get_service :: +    Ptr NetworkService ->                   -- _obj : TInterface "Gio" "NetworkService"+    IO CString+++networkServiceGetService ::+    (MonadIO m, NetworkServiceK a) =>+    a ->                                    -- _obj+    m T.Text+networkServiceGetService _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_network_service_get_service _obj'+    checkUnexpectedReturnNULL "g_network_service_get_service" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method NetworkService::set_scheme+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "NetworkService", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "scheme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "NetworkService", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "scheme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_network_service_set_scheme" g_network_service_set_scheme :: +    Ptr NetworkService ->                   -- _obj : TInterface "Gio" "NetworkService"+    CString ->                              -- scheme : TBasicType TUTF8+    IO ()+++networkServiceSetScheme ::+    (MonadIO m, NetworkServiceK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- scheme+    m ()+networkServiceSetScheme _obj scheme = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    scheme' <- textToCString scheme+    g_network_service_set_scheme _obj' scheme'+    touchManagedPtr _obj+    freeMem scheme'+    return ()++
+ GI/Gio/Objects/NetworkService.hs-boot view
@@ -0,0 +1,17 @@+module GI.Gio.Objects.NetworkService where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype NetworkService = NetworkService (ForeignPtr NetworkService)+instance GObject NetworkService where+class GObject o => NetworkServiceK o+instance (GObject o, IsDescendantOf NetworkService o) => NetworkServiceK o+data NetworkServiceDomainPropertyInfo+data NetworkServiceProtocolPropertyInfo+data NetworkServiceSchemePropertyInfo+data NetworkServiceServicePropertyInfo
+ GI/Gio/Objects/Notification.hs view
@@ -0,0 +1,403 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.Notification+    ( ++-- * Exported types+    Notification(..)                        ,+    NotificationK                           ,+    toNotification                          ,+    noNotification                          ,+++ -- * Methods+-- ** notificationAddButton+    notificationAddButton                   ,+++-- ** notificationAddButtonWithTarget+    notificationAddButtonWithTarget         ,+++-- ** notificationNew+    notificationNew                         ,+++-- ** notificationSetBody+    notificationSetBody                     ,+++-- ** notificationSetDefaultAction+    notificationSetDefaultAction            ,+++-- ** notificationSetDefaultActionAndTarget+    notificationSetDefaultActionAndTarget   ,+++-- ** notificationSetIcon+    notificationSetIcon                     ,+++-- ** notificationSetPriority+    notificationSetPriority                 ,+++-- ** notificationSetTitle+    notificationSetTitle                    ,+++-- ** notificationSetUrgent+    notificationSetUrgent                   ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype Notification = Notification (ForeignPtr Notification)+foreign import ccall "g_notification_get_type"+    c_g_notification_get_type :: IO GType++type instance ParentTypes Notification = NotificationParentTypes+type NotificationParentTypes = '[GObject.Object]++instance GObject Notification where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_notification_get_type+    ++class GObject o => NotificationK o+instance (GObject o, IsDescendantOf Notification o) => NotificationK o++toNotification :: NotificationK o => o -> IO Notification+toNotification = unsafeCastTo Notification++noNotification :: Maybe Notification+noNotification = Nothing++type instance AttributeList Notification = NotificationAttributeList+type NotificationAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList Notification = NotificationSignalList+type NotificationSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Notification::new+-- method type : Constructor+-- Args : [Arg {argName = "title", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "title", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Notification"+-- throws : False+-- Skip return : False++foreign import ccall "g_notification_new" g_notification_new :: +    CString ->                              -- title : TBasicType TUTF8+    IO (Ptr Notification)+++notificationNew ::+    (MonadIO m) =>+    T.Text ->                               -- title+    m Notification+notificationNew title = liftIO $ do+    title' <- textToCString title+    result <- g_notification_new title'+    checkUnexpectedReturnNULL "g_notification_new" result+    result' <- (wrapObject Notification) result+    freeMem title'+    return result'++-- method Notification::add_button+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Notification", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detailed_action", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Notification", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detailed_action", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_notification_add_button" g_notification_add_button :: +    Ptr Notification ->                     -- _obj : TInterface "Gio" "Notification"+    CString ->                              -- label : TBasicType TUTF8+    CString ->                              -- detailed_action : TBasicType TUTF8+    IO ()+++notificationAddButton ::+    (MonadIO m, NotificationK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- label+    T.Text ->                               -- detailed_action+    m ()+notificationAddButton _obj label detailed_action = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    label' <- textToCString label+    detailed_action' <- textToCString detailed_action+    g_notification_add_button _obj' label' detailed_action'+    touchManagedPtr _obj+    freeMem label'+    freeMem detailed_action'+    return ()++-- method Notification::add_button_with_target+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Notification", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "target", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Notification", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "target", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_notification_add_button_with_target_value" g_notification_add_button_with_target_value :: +    Ptr Notification ->                     -- _obj : TInterface "Gio" "Notification"+    CString ->                              -- label : TBasicType TUTF8+    CString ->                              -- action : TBasicType TUTF8+    Ptr GVariant ->                         -- target : TVariant+    IO ()+++notificationAddButtonWithTarget ::+    (MonadIO m, NotificationK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- label+    T.Text ->                               -- action+    Maybe (GVariant) ->                     -- target+    m ()+notificationAddButtonWithTarget _obj label action target = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    label' <- textToCString label+    action' <- textToCString action+    maybeTarget <- case target of+        Nothing -> return nullPtr+        Just jTarget -> do+            let jTarget' = unsafeManagedPtrGetPtr jTarget+            return jTarget'+    g_notification_add_button_with_target_value _obj' label' action' maybeTarget+    touchManagedPtr _obj+    freeMem label'+    freeMem action'+    return ()++-- method Notification::set_body+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Notification", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "body", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Notification", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "body", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_notification_set_body" g_notification_set_body :: +    Ptr Notification ->                     -- _obj : TInterface "Gio" "Notification"+    CString ->                              -- body : TBasicType TUTF8+    IO ()+++notificationSetBody ::+    (MonadIO m, NotificationK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- body+    m ()+notificationSetBody _obj body = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeBody <- case body of+        Nothing -> return nullPtr+        Just jBody -> do+            jBody' <- textToCString jBody+            return jBody'+    g_notification_set_body _obj' maybeBody+    touchManagedPtr _obj+    freeMem maybeBody+    return ()++-- method Notification::set_default_action+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Notification", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detailed_action", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Notification", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detailed_action", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_notification_set_default_action" g_notification_set_default_action :: +    Ptr Notification ->                     -- _obj : TInterface "Gio" "Notification"+    CString ->                              -- detailed_action : TBasicType TUTF8+    IO ()+++notificationSetDefaultAction ::+    (MonadIO m, NotificationK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- detailed_action+    m ()+notificationSetDefaultAction _obj detailed_action = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    detailed_action' <- textToCString detailed_action+    g_notification_set_default_action _obj' detailed_action'+    touchManagedPtr _obj+    freeMem detailed_action'+    return ()++-- method Notification::set_default_action_and_target+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Notification", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "target", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Notification", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "target", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_notification_set_default_action_and_target_value" g_notification_set_default_action_and_target_value :: +    Ptr Notification ->                     -- _obj : TInterface "Gio" "Notification"+    CString ->                              -- action : TBasicType TUTF8+    Ptr GVariant ->                         -- target : TVariant+    IO ()+++notificationSetDefaultActionAndTarget ::+    (MonadIO m, NotificationK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- action+    Maybe (GVariant) ->                     -- target+    m ()+notificationSetDefaultActionAndTarget _obj action target = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    action' <- textToCString action+    maybeTarget <- case target of+        Nothing -> return nullPtr+        Just jTarget -> do+            let jTarget' = unsafeManagedPtrGetPtr jTarget+            return jTarget'+    g_notification_set_default_action_and_target_value _obj' action' maybeTarget+    touchManagedPtr _obj+    freeMem action'+    return ()++-- method Notification::set_icon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Notification", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon", argType = TInterface "Gio" "Icon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Notification", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon", argType = TInterface "Gio" "Icon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_notification_set_icon" g_notification_set_icon :: +    Ptr Notification ->                     -- _obj : TInterface "Gio" "Notification"+    Ptr Icon ->                             -- icon : TInterface "Gio" "Icon"+    IO ()+++notificationSetIcon ::+    (MonadIO m, NotificationK a, IconK b) =>+    a ->                                    -- _obj+    b ->                                    -- icon+    m ()+notificationSetIcon _obj icon = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let icon' = unsafeManagedPtrCastPtr icon+    g_notification_set_icon _obj' icon'+    touchManagedPtr _obj+    touchManagedPtr icon+    return ()++-- method Notification::set_priority+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Notification", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "priority", argType = TInterface "Gio" "NotificationPriority", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Notification", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "priority", argType = TInterface "Gio" "NotificationPriority", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_notification_set_priority" g_notification_set_priority :: +    Ptr Notification ->                     -- _obj : TInterface "Gio" "Notification"+    CUInt ->                                -- priority : TInterface "Gio" "NotificationPriority"+    IO ()+++notificationSetPriority ::+    (MonadIO m, NotificationK a) =>+    a ->                                    -- _obj+    NotificationPriority ->                 -- priority+    m ()+notificationSetPriority _obj priority = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let priority' = (fromIntegral . fromEnum) priority+    g_notification_set_priority _obj' priority'+    touchManagedPtr _obj+    return ()++-- method Notification::set_title+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Notification", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "title", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Notification", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "title", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_notification_set_title" g_notification_set_title :: +    Ptr Notification ->                     -- _obj : TInterface "Gio" "Notification"+    CString ->                              -- title : TBasicType TUTF8+    IO ()+++notificationSetTitle ::+    (MonadIO m, NotificationK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- title+    m ()+notificationSetTitle _obj title = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    title' <- textToCString title+    g_notification_set_title _obj' title'+    touchManagedPtr _obj+    freeMem title'+    return ()++-- method Notification::set_urgent+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Notification", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "urgent", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Notification", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "urgent", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_notification_set_urgent" g_notification_set_urgent :: +    Ptr Notification ->                     -- _obj : TInterface "Gio" "Notification"+    CInt ->                                 -- urgent : TBasicType TBoolean+    IO ()+++notificationSetUrgent ::+    (MonadIO m, NotificationK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- urgent+    m ()+notificationSetUrgent _obj urgent = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let urgent' = (fromIntegral . fromEnum) urgent+    g_notification_set_urgent _obj' urgent'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Objects/Notification.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Objects.Notification where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Notification = Notification (ForeignPtr Notification)+instance GObject Notification where+class GObject o => NotificationK o+instance (GObject o, IsDescendantOf Notification o) => NotificationK o
+ GI/Gio/Objects/OutputStream.hs view
@@ -0,0 +1,1027 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.OutputStream+    ( ++-- * Exported types+    OutputStream(..)                        ,+    OutputStreamK                           ,+    toOutputStream                          ,+    noOutputStream                          ,+++ -- * Methods+-- ** outputStreamClearPending+    outputStreamClearPending                ,+++-- ** outputStreamClose+    outputStreamClose                       ,+++-- ** outputStreamCloseAsync+    outputStreamCloseAsync                  ,+++-- ** outputStreamCloseFinish+    outputStreamCloseFinish                 ,+++-- ** outputStreamFlush+    outputStreamFlush                       ,+++-- ** outputStreamFlushAsync+    outputStreamFlushAsync                  ,+++-- ** outputStreamFlushFinish+    outputStreamFlushFinish                 ,+++-- ** outputStreamHasPending+    outputStreamHasPending                  ,+++-- ** outputStreamIsClosed+    outputStreamIsClosed                    ,+++-- ** outputStreamIsClosing+    outputStreamIsClosing                   ,+++-- ** outputStreamSetPending+    outputStreamSetPending                  ,+++-- ** outputStreamSplice+    outputStreamSplice                      ,+++-- ** outputStreamSpliceAsync+    outputStreamSpliceAsync                 ,+++-- ** outputStreamSpliceFinish+    outputStreamSpliceFinish                ,+++-- ** outputStreamWrite+    outputStreamWrite                       ,+++-- ** outputStreamWriteAll+    outputStreamWriteAll                    ,+++-- ** outputStreamWriteAllAsync+    outputStreamWriteAllAsync               ,+++-- ** outputStreamWriteAllFinish+    outputStreamWriteAllFinish              ,+++-- ** outputStreamWriteAsync+    outputStreamWriteAsync                  ,+++-- ** outputStreamWriteBytes+    outputStreamWriteBytes                  ,+++-- ** outputStreamWriteBytesAsync+    outputStreamWriteBytesAsync             ,+++-- ** outputStreamWriteBytesFinish+    outputStreamWriteBytesFinish            ,+++-- ** outputStreamWriteFinish+    outputStreamWriteFinish                 ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype OutputStream = OutputStream (ForeignPtr OutputStream)+foreign import ccall "g_output_stream_get_type"+    c_g_output_stream_get_type :: IO GType++type instance ParentTypes OutputStream = OutputStreamParentTypes+type OutputStreamParentTypes = '[GObject.Object]++instance GObject OutputStream where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_output_stream_get_type+    ++class GObject o => OutputStreamK o+instance (GObject o, IsDescendantOf OutputStream o) => OutputStreamK o++toOutputStream :: OutputStreamK o => o -> IO OutputStream+toOutputStream = unsafeCastTo OutputStream++noOutputStream :: Maybe OutputStream+noOutputStream = Nothing++type instance AttributeList OutputStream = OutputStreamAttributeList+type OutputStreamAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList OutputStream = OutputStreamSignalList+type OutputStreamSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method OutputStream::clear_pending+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_output_stream_clear_pending" g_output_stream_clear_pending :: +    Ptr OutputStream ->                     -- _obj : TInterface "Gio" "OutputStream"+    IO ()+++outputStreamClearPending ::+    (MonadIO m, OutputStreamK a) =>+    a ->                                    -- _obj+    m ()+outputStreamClearPending _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_output_stream_clear_pending _obj'+    touchManagedPtr _obj+    return ()++-- method OutputStream::close+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_output_stream_close" g_output_stream_close :: +    Ptr OutputStream ->                     -- _obj : TInterface "Gio" "OutputStream"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++outputStreamClose ::+    (MonadIO m, OutputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m ()+outputStreamClose _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_output_stream_close _obj' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method OutputStream::close_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_output_stream_close_async" g_output_stream_close_async :: +    Ptr OutputStream ->                     -- _obj : TInterface "Gio" "OutputStream"+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++outputStreamCloseAsync ::+    (MonadIO m, OutputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+outputStreamCloseAsync _obj io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_output_stream_close_async _obj' io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method OutputStream::close_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_output_stream_close_finish" g_output_stream_close_finish :: +    Ptr OutputStream ->                     -- _obj : TInterface "Gio" "OutputStream"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++outputStreamCloseFinish ::+    (MonadIO m, OutputStreamK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+outputStreamCloseFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_output_stream_close_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++-- method OutputStream::flush+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_output_stream_flush" g_output_stream_flush :: +    Ptr OutputStream ->                     -- _obj : TInterface "Gio" "OutputStream"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++outputStreamFlush ::+    (MonadIO m, OutputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m ()+outputStreamFlush _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_output_stream_flush _obj' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method OutputStream::flush_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_output_stream_flush_async" g_output_stream_flush_async :: +    Ptr OutputStream ->                     -- _obj : TInterface "Gio" "OutputStream"+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++outputStreamFlushAsync ::+    (MonadIO m, OutputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+outputStreamFlushAsync _obj io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_output_stream_flush_async _obj' io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method OutputStream::flush_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_output_stream_flush_finish" g_output_stream_flush_finish :: +    Ptr OutputStream ->                     -- _obj : TInterface "Gio" "OutputStream"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++outputStreamFlushFinish ::+    (MonadIO m, OutputStreamK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+outputStreamFlushFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_output_stream_flush_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++-- method OutputStream::has_pending+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_output_stream_has_pending" g_output_stream_has_pending :: +    Ptr OutputStream ->                     -- _obj : TInterface "Gio" "OutputStream"+    IO CInt+++outputStreamHasPending ::+    (MonadIO m, OutputStreamK a) =>+    a ->                                    -- _obj+    m Bool+outputStreamHasPending _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_output_stream_has_pending _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method OutputStream::is_closed+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_output_stream_is_closed" g_output_stream_is_closed :: +    Ptr OutputStream ->                     -- _obj : TInterface "Gio" "OutputStream"+    IO CInt+++outputStreamIsClosed ::+    (MonadIO m, OutputStreamK a) =>+    a ->                                    -- _obj+    m Bool+outputStreamIsClosed _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_output_stream_is_closed _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method OutputStream::is_closing+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_output_stream_is_closing" g_output_stream_is_closing :: +    Ptr OutputStream ->                     -- _obj : TInterface "Gio" "OutputStream"+    IO CInt+++outputStreamIsClosing ::+    (MonadIO m, OutputStreamK a) =>+    a ->                                    -- _obj+    m Bool+outputStreamIsClosing _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_output_stream_is_closing _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method OutputStream::set_pending+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_output_stream_set_pending" g_output_stream_set_pending :: +    Ptr OutputStream ->                     -- _obj : TInterface "Gio" "OutputStream"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++outputStreamSetPending ::+    (MonadIO m, OutputStreamK a) =>+    a ->                                    -- _obj+    m ()+outputStreamSetPending _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    onException (do+        _ <- propagateGError $ g_output_stream_set_pending _obj'+        touchManagedPtr _obj+        return ()+     ) (do+        return ()+     )++-- method OutputStream::splice+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "OutputStreamSpliceFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "OutputStreamSpliceFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : True+-- Skip return : False++foreign import ccall "g_output_stream_splice" g_output_stream_splice :: +    Ptr OutputStream ->                     -- _obj : TInterface "Gio" "OutputStream"+    Ptr InputStream ->                      -- source : TInterface "Gio" "InputStream"+    CUInt ->                                -- flags : TInterface "Gio" "OutputStreamSpliceFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO Int64+++outputStreamSplice ::+    (MonadIO m, OutputStreamK a, InputStreamK b, CancellableK c) =>+    a ->                                    -- _obj+    b ->                                    -- source+    [OutputStreamSpliceFlags] ->            -- flags+    Maybe (c) ->                            -- cancellable+    m Int64+outputStreamSplice _obj source flags cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let source' = unsafeManagedPtrCastPtr source+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_output_stream_splice _obj' source' flags' maybeCancellable+        touchManagedPtr _obj+        touchManagedPtr source+        whenJust cancellable touchManagedPtr+        return result+     ) (do+        return ()+     )++-- method OutputStream::splice_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "OutputStreamSpliceFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "OutputStreamSpliceFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_output_stream_splice_async" g_output_stream_splice_async :: +    Ptr OutputStream ->                     -- _obj : TInterface "Gio" "OutputStream"+    Ptr InputStream ->                      -- source : TInterface "Gio" "InputStream"+    CUInt ->                                -- flags : TInterface "Gio" "OutputStreamSpliceFlags"+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++outputStreamSpliceAsync ::+    (MonadIO m, OutputStreamK a, InputStreamK b, CancellableK c) =>+    a ->                                    -- _obj+    b ->                                    -- source+    [OutputStreamSpliceFlags] ->            -- flags+    Int32 ->                                -- io_priority+    Maybe (c) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+outputStreamSpliceAsync _obj source flags io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let source' = unsafeManagedPtrCastPtr source+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_output_stream_splice_async _obj' source' flags' io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    touchManagedPtr source+    whenJust cancellable touchManagedPtr+    return ()++-- method OutputStream::splice_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : True+-- Skip return : False++foreign import ccall "g_output_stream_splice_finish" g_output_stream_splice_finish :: +    Ptr OutputStream ->                     -- _obj : TInterface "Gio" "OutputStream"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO Int64+++outputStreamSpliceFinish ::+    (MonadIO m, OutputStreamK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m Int64+outputStreamSpliceFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        result <- propagateGError $ g_output_stream_splice_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return result+     ) (do+        return ()+     )++-- method OutputStream::write+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : True+-- Skip return : False++foreign import ccall "g_output_stream_write" g_output_stream_write :: +    Ptr OutputStream ->                     -- _obj : TInterface "Gio" "OutputStream"+    Ptr Word8 ->                            -- buffer : TCArray False (-1) 2 (TBasicType TUInt8)+    Word64 ->                               -- count : TBasicType TUInt64+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO Int64+++outputStreamWrite ::+    (MonadIO m, OutputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    ByteString ->                           -- buffer+    Maybe (b) ->                            -- cancellable+    m Int64+outputStreamWrite _obj buffer cancellable = liftIO $ do+    let count = fromIntegral $ B.length buffer+    let _obj' = unsafeManagedPtrCastPtr _obj+    buffer' <- packByteString buffer+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_output_stream_write _obj' buffer' count maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem buffer'+        return result+     ) (do+        freeMem buffer'+     )++-- method OutputStream::write_all+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "bytes_written", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_output_stream_write_all" g_output_stream_write_all :: +    Ptr OutputStream ->                     -- _obj : TInterface "Gio" "OutputStream"+    Ptr Word8 ->                            -- buffer : TCArray False (-1) 2 (TBasicType TUInt8)+    Word64 ->                               -- count : TBasicType TUInt64+    Ptr Word64 ->                           -- bytes_written : TBasicType TUInt64+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++outputStreamWriteAll ::+    (MonadIO m, OutputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    ByteString ->                           -- buffer+    Maybe (b) ->                            -- cancellable+    m (Word64)+outputStreamWriteAll _obj buffer cancellable = liftIO $ do+    let count = fromIntegral $ B.length buffer+    let _obj' = unsafeManagedPtrCastPtr _obj+    buffer' <- packByteString buffer+    bytes_written <- allocMem :: IO (Ptr Word64)+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_output_stream_write_all _obj' buffer' count bytes_written maybeCancellable+        bytes_written' <- peek bytes_written+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem buffer'+        freeMem bytes_written+        return bytes_written'+     ) (do+        freeMem buffer'+        freeMem bytes_written+     )++-- method OutputStream::write_all_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_output_stream_write_all_async" g_output_stream_write_all_async :: +    Ptr OutputStream ->                     -- _obj : TInterface "Gio" "OutputStream"+    Ptr Word8 ->                            -- buffer : TCArray False (-1) 2 (TBasicType TUInt8)+    Word64 ->                               -- count : TBasicType TUInt64+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++outputStreamWriteAllAsync ::+    (MonadIO m, OutputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    ByteString ->                           -- buffer+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+outputStreamWriteAllAsync _obj buffer io_priority cancellable callback = liftIO $ do+    let count = fromIntegral $ B.length buffer+    let _obj' = unsafeManagedPtrCastPtr _obj+    buffer' <- packByteString buffer+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_output_stream_write_all_async _obj' buffer' count io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    freeMem buffer'+    return ()++-- method OutputStream::write_all_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "bytes_written", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_output_stream_write_all_finish" g_output_stream_write_all_finish :: +    Ptr OutputStream ->                     -- _obj : TInterface "Gio" "OutputStream"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr Word64 ->                           -- bytes_written : TBasicType TUInt64+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++outputStreamWriteAllFinish ::+    (MonadIO m, OutputStreamK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m (Word64)+outputStreamWriteAllFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    bytes_written <- allocMem :: IO (Ptr Word64)+    onException (do+        _ <- propagateGError $ g_output_stream_write_all_finish _obj' result_' bytes_written+        bytes_written' <- peek bytes_written+        touchManagedPtr _obj+        touchManagedPtr result_+        freeMem bytes_written+        return bytes_written'+     ) (do+        freeMem bytes_written+     )++-- method OutputStream::write_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_output_stream_write_async" g_output_stream_write_async :: +    Ptr OutputStream ->                     -- _obj : TInterface "Gio" "OutputStream"+    Ptr Word8 ->                            -- buffer : TCArray False (-1) 2 (TBasicType TUInt8)+    Word64 ->                               -- count : TBasicType TUInt64+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++outputStreamWriteAsync ::+    (MonadIO m, OutputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    ByteString ->                           -- buffer+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+outputStreamWriteAsync _obj buffer io_priority cancellable callback = liftIO $ do+    let count = fromIntegral $ B.length buffer+    let _obj' = unsafeManagedPtrCastPtr _obj+    buffer' <- packByteString buffer+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_output_stream_write_async _obj' buffer' count io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    freeMem buffer'+    return ()++-- method OutputStream::write_bytes+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "bytes", argType = TInterface "GLib" "Bytes", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "bytes", argType = TInterface "GLib" "Bytes", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : True+-- Skip return : False++foreign import ccall "g_output_stream_write_bytes" g_output_stream_write_bytes :: +    Ptr OutputStream ->                     -- _obj : TInterface "Gio" "OutputStream"+    Ptr GLib.Bytes ->                       -- bytes : TInterface "GLib" "Bytes"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO Int64+++outputStreamWriteBytes ::+    (MonadIO m, OutputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    GLib.Bytes ->                           -- bytes+    Maybe (b) ->                            -- cancellable+    m Int64+outputStreamWriteBytes _obj bytes cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let bytes' = unsafeManagedPtrGetPtr bytes+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_output_stream_write_bytes _obj' bytes' maybeCancellable+        touchManagedPtr _obj+        touchManagedPtr bytes+        whenJust cancellable touchManagedPtr+        return result+     ) (do+        return ()+     )++-- method OutputStream::write_bytes_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "bytes", argType = TInterface "GLib" "Bytes", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "bytes", argType = TInterface "GLib" "Bytes", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_output_stream_write_bytes_async" g_output_stream_write_bytes_async :: +    Ptr OutputStream ->                     -- _obj : TInterface "Gio" "OutputStream"+    Ptr GLib.Bytes ->                       -- bytes : TInterface "GLib" "Bytes"+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++outputStreamWriteBytesAsync ::+    (MonadIO m, OutputStreamK a, CancellableK b) =>+    a ->                                    -- _obj+    GLib.Bytes ->                           -- bytes+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+outputStreamWriteBytesAsync _obj bytes io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let bytes' = unsafeManagedPtrGetPtr bytes+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_output_stream_write_bytes_async _obj' bytes' io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    touchManagedPtr bytes+    whenJust cancellable touchManagedPtr+    return ()++-- method OutputStream::write_bytes_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : True+-- Skip return : False++foreign import ccall "g_output_stream_write_bytes_finish" g_output_stream_write_bytes_finish :: +    Ptr OutputStream ->                     -- _obj : TInterface "Gio" "OutputStream"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO Int64+++outputStreamWriteBytesFinish ::+    (MonadIO m, OutputStreamK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m Int64+outputStreamWriteBytesFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        result <- propagateGError $ g_output_stream_write_bytes_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return result+     ) (do+        return ()+     )++-- method OutputStream::write_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : True+-- Skip return : False++foreign import ccall "g_output_stream_write_finish" g_output_stream_write_finish :: +    Ptr OutputStream ->                     -- _obj : TInterface "Gio" "OutputStream"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO Int64+++outputStreamWriteFinish ::+    (MonadIO m, OutputStreamK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m Int64+outputStreamWriteFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        result <- propagateGError $ g_output_stream_write_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return result+     ) (do+        return ()+     )++
+ GI/Gio/Objects/OutputStream.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Objects.OutputStream where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype OutputStream = OutputStream (ForeignPtr OutputStream)+instance GObject OutputStream where+class GObject o => OutputStreamK o+instance (GObject o, IsDescendantOf OutputStream o) => OutputStreamK o
+ GI/Gio/Objects/Permission.hs view
@@ -0,0 +1,507 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.Permission+    ( ++-- * Exported types+    Permission(..)                          ,+    PermissionK                             ,+    toPermission                            ,+    noPermission                            ,+++ -- * Methods+-- ** permissionAcquire+    permissionAcquire                       ,+++-- ** permissionAcquireAsync+    permissionAcquireAsync                  ,+++-- ** permissionAcquireFinish+    permissionAcquireFinish                 ,+++-- ** permissionGetAllowed+    permissionGetAllowed                    ,+++-- ** permissionGetCanAcquire+    permissionGetCanAcquire                 ,+++-- ** permissionGetCanRelease+    permissionGetCanRelease                 ,+++-- ** permissionImplUpdate+    permissionImplUpdate                    ,+++-- ** permissionRelease+    permissionRelease                       ,+++-- ** permissionReleaseAsync+    permissionReleaseAsync                  ,+++-- ** permissionReleaseFinish+    permissionReleaseFinish                 ,+++++ -- * Properties+-- ** Allowed+    PermissionAllowedPropertyInfo           ,+    getPermissionAllowed                    ,+++-- ** CanAcquire+    PermissionCanAcquirePropertyInfo        ,+    getPermissionCanAcquire                 ,+++-- ** CanRelease+    PermissionCanReleasePropertyInfo        ,+    getPermissionCanRelease                 ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype Permission = Permission (ForeignPtr Permission)+foreign import ccall "g_permission_get_type"+    c_g_permission_get_type :: IO GType++type instance ParentTypes Permission = PermissionParentTypes+type PermissionParentTypes = '[GObject.Object]++instance GObject Permission where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_permission_get_type+    ++class GObject o => PermissionK o+instance (GObject o, IsDescendantOf Permission o) => PermissionK o++toPermission :: PermissionK o => o -> IO Permission+toPermission = unsafeCastTo Permission++noPermission :: Maybe Permission+noPermission = Nothing++-- VVV Prop "allowed"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getPermissionAllowed :: (MonadIO m, PermissionK o) => o -> m Bool+getPermissionAllowed obj = liftIO $ getObjectPropertyBool obj "allowed"++data PermissionAllowedPropertyInfo+instance AttrInfo PermissionAllowedPropertyInfo where+    type AttrAllowedOps PermissionAllowedPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint PermissionAllowedPropertyInfo = (~) ()+    type AttrBaseTypeConstraint PermissionAllowedPropertyInfo = PermissionK+    type AttrGetType PermissionAllowedPropertyInfo = Bool+    type AttrLabel PermissionAllowedPropertyInfo = "Permission::allowed"+    attrGet _ = getPermissionAllowed+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "can-acquire"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getPermissionCanAcquire :: (MonadIO m, PermissionK o) => o -> m Bool+getPermissionCanAcquire obj = liftIO $ getObjectPropertyBool obj "can-acquire"++data PermissionCanAcquirePropertyInfo+instance AttrInfo PermissionCanAcquirePropertyInfo where+    type AttrAllowedOps PermissionCanAcquirePropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint PermissionCanAcquirePropertyInfo = (~) ()+    type AttrBaseTypeConstraint PermissionCanAcquirePropertyInfo = PermissionK+    type AttrGetType PermissionCanAcquirePropertyInfo = Bool+    type AttrLabel PermissionCanAcquirePropertyInfo = "Permission::can-acquire"+    attrGet _ = getPermissionCanAcquire+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "can-release"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getPermissionCanRelease :: (MonadIO m, PermissionK o) => o -> m Bool+getPermissionCanRelease obj = liftIO $ getObjectPropertyBool obj "can-release"++data PermissionCanReleasePropertyInfo+instance AttrInfo PermissionCanReleasePropertyInfo where+    type AttrAllowedOps PermissionCanReleasePropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint PermissionCanReleasePropertyInfo = (~) ()+    type AttrBaseTypeConstraint PermissionCanReleasePropertyInfo = PermissionK+    type AttrGetType PermissionCanReleasePropertyInfo = Bool+    type AttrLabel PermissionCanReleasePropertyInfo = "Permission::can-release"+    attrGet _ = getPermissionCanRelease+    attrSet _ = undefined+    attrConstruct _ = undefined++type instance AttributeList Permission = PermissionAttributeList+type PermissionAttributeList = ('[ '("allowed", PermissionAllowedPropertyInfo), '("can-acquire", PermissionCanAcquirePropertyInfo), '("can-release", PermissionCanReleasePropertyInfo)] :: [(Symbol, *)])++type instance SignalList Permission = PermissionSignalList+type PermissionSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Permission::acquire+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Permission", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Permission", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_permission_acquire" g_permission_acquire :: +    Ptr Permission ->                       -- _obj : TInterface "Gio" "Permission"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++permissionAcquire ::+    (MonadIO m, PermissionK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m ()+permissionAcquire _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_permission_acquire _obj' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method Permission::acquire_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Permission", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Permission", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_permission_acquire_async" g_permission_acquire_async :: +    Ptr Permission ->                       -- _obj : TInterface "Gio" "Permission"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++permissionAcquireAsync ::+    (MonadIO m, PermissionK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+permissionAcquireAsync _obj cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_permission_acquire_async _obj' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method Permission::acquire_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Permission", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Permission", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_permission_acquire_finish" g_permission_acquire_finish :: +    Ptr Permission ->                       -- _obj : TInterface "Gio" "Permission"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++permissionAcquireFinish ::+    (MonadIO m, PermissionK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+permissionAcquireFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_permission_acquire_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++-- method Permission::get_allowed+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Permission", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Permission", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_permission_get_allowed" g_permission_get_allowed :: +    Ptr Permission ->                       -- _obj : TInterface "Gio" "Permission"+    IO CInt+++permissionGetAllowed ::+    (MonadIO m, PermissionK a) =>+    a ->                                    -- _obj+    m Bool+permissionGetAllowed _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_permission_get_allowed _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Permission::get_can_acquire+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Permission", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Permission", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_permission_get_can_acquire" g_permission_get_can_acquire :: +    Ptr Permission ->                       -- _obj : TInterface "Gio" "Permission"+    IO CInt+++permissionGetCanAcquire ::+    (MonadIO m, PermissionK a) =>+    a ->                                    -- _obj+    m Bool+permissionGetCanAcquire _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_permission_get_can_acquire _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Permission::get_can_release+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Permission", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Permission", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_permission_get_can_release" g_permission_get_can_release :: +    Ptr Permission ->                       -- _obj : TInterface "Gio" "Permission"+    IO CInt+++permissionGetCanRelease ::+    (MonadIO m, PermissionK a) =>+    a ->                                    -- _obj+    m Bool+permissionGetCanRelease _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_permission_get_can_release _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Permission::impl_update+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Permission", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "allowed", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "can_acquire", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "can_release", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Permission", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "allowed", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "can_acquire", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "can_release", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_permission_impl_update" g_permission_impl_update :: +    Ptr Permission ->                       -- _obj : TInterface "Gio" "Permission"+    CInt ->                                 -- allowed : TBasicType TBoolean+    CInt ->                                 -- can_acquire : TBasicType TBoolean+    CInt ->                                 -- can_release : TBasicType TBoolean+    IO ()+++permissionImplUpdate ::+    (MonadIO m, PermissionK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- allowed+    Bool ->                                 -- can_acquire+    Bool ->                                 -- can_release+    m ()+permissionImplUpdate _obj allowed can_acquire can_release = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let allowed' = (fromIntegral . fromEnum) allowed+    let can_acquire' = (fromIntegral . fromEnum) can_acquire+    let can_release' = (fromIntegral . fromEnum) can_release+    g_permission_impl_update _obj' allowed' can_acquire' can_release'+    touchManagedPtr _obj+    return ()++-- method Permission::release+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Permission", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Permission", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_permission_release" g_permission_release :: +    Ptr Permission ->                       -- _obj : TInterface "Gio" "Permission"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++permissionRelease ::+    (MonadIO m, PermissionK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m ()+permissionRelease _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_permission_release _obj' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method Permission::release_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Permission", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Permission", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_permission_release_async" g_permission_release_async :: +    Ptr Permission ->                       -- _obj : TInterface "Gio" "Permission"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++permissionReleaseAsync ::+    (MonadIO m, PermissionK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+permissionReleaseAsync _obj cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_permission_release_async _obj' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method Permission::release_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Permission", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Permission", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_permission_release_finish" g_permission_release_finish :: +    Ptr Permission ->                       -- _obj : TInterface "Gio" "Permission"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++permissionReleaseFinish ::+    (MonadIO m, PermissionK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+permissionReleaseFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_permission_release_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++
+ GI/Gio/Objects/Permission.hs-boot view
@@ -0,0 +1,16 @@+module GI.Gio.Objects.Permission where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Permission = Permission (ForeignPtr Permission)+instance GObject Permission where+class GObject o => PermissionK o+instance (GObject o, IsDescendantOf Permission o) => PermissionK o+data PermissionAllowedPropertyInfo+data PermissionCanAcquirePropertyInfo+data PermissionCanReleasePropertyInfo
+ GI/Gio/Objects/PropertyAction.hs view
@@ -0,0 +1,298 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.PropertyAction+    ( ++-- * Exported types+    PropertyAction(..)                      ,+    PropertyActionK                         ,+    toPropertyAction                        ,+    noPropertyAction                        ,+++ -- * Methods+-- ** propertyActionNew+    propertyActionNew                       ,+++++ -- * Properties+-- ** Enabled+    PropertyActionEnabledPropertyInfo       ,+    getPropertyActionEnabled                ,+++-- ** InvertBoolean+    PropertyActionInvertBooleanPropertyInfo ,+    constructPropertyActionInvertBoolean    ,+    getPropertyActionInvertBoolean          ,+++-- ** Name+    PropertyActionNamePropertyInfo          ,+    constructPropertyActionName             ,+    getPropertyActionName                   ,+++-- ** Object+    PropertyActionObjectPropertyInfo        ,+    constructPropertyActionObject           ,+++-- ** ParameterType+    PropertyActionParameterTypePropertyInfo ,+    getPropertyActionParameterType          ,+++-- ** PropertyName+    PropertyActionPropertyNamePropertyInfo  ,+    constructPropertyActionPropertyName     ,+++-- ** State+    PropertyActionStatePropertyInfo         ,+    getPropertyActionState                  ,+++-- ** StateType+    PropertyActionStateTypePropertyInfo     ,+    getPropertyActionStateType              ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype PropertyAction = PropertyAction (ForeignPtr PropertyAction)+foreign import ccall "g_property_action_get_type"+    c_g_property_action_get_type :: IO GType++type instance ParentTypes PropertyAction = PropertyActionParentTypes+type PropertyActionParentTypes = '[GObject.Object, Action]++instance GObject PropertyAction where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_property_action_get_type+    ++class GObject o => PropertyActionK o+instance (GObject o, IsDescendantOf PropertyAction o) => PropertyActionK o++toPropertyAction :: PropertyActionK o => o -> IO PropertyAction+toPropertyAction = unsafeCastTo PropertyAction++noPropertyAction :: Maybe PropertyAction+noPropertyAction = Nothing++--- XXX Duplicated object with different types:+  --- Name {namespace = "Gio", name = "PropertyAction"} -> Property {propName = "name", propType = TBasicType TUTF8, propFlags = [PropertyReadable,PropertyWritable,PropertyConstructOnly], propTransfer = TransferNothing, propDeprecated = Nothing}+  --- Name {namespace = "Gio", name = "Action"} -> Property {propName = "name", propType = TBasicType TUTF8, propFlags = [PropertyReadable], propTransfer = TransferNothing, propDeprecated = Nothing}+-- VVV Prop "enabled"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getPropertyActionEnabled :: (MonadIO m, PropertyActionK o) => o -> m Bool+getPropertyActionEnabled obj = liftIO $ getObjectPropertyBool obj "enabled"++data PropertyActionEnabledPropertyInfo+instance AttrInfo PropertyActionEnabledPropertyInfo where+    type AttrAllowedOps PropertyActionEnabledPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint PropertyActionEnabledPropertyInfo = (~) ()+    type AttrBaseTypeConstraint PropertyActionEnabledPropertyInfo = PropertyActionK+    type AttrGetType PropertyActionEnabledPropertyInfo = Bool+    type AttrLabel PropertyActionEnabledPropertyInfo = "PropertyAction::enabled"+    attrGet _ = getPropertyActionEnabled+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "invert-boolean"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getPropertyActionInvertBoolean :: (MonadIO m, PropertyActionK o) => o -> m Bool+getPropertyActionInvertBoolean obj = liftIO $ getObjectPropertyBool obj "invert-boolean"++constructPropertyActionInvertBoolean :: Bool -> IO ([Char], GValue)+constructPropertyActionInvertBoolean val = constructObjectPropertyBool "invert-boolean" val++data PropertyActionInvertBooleanPropertyInfo+instance AttrInfo PropertyActionInvertBooleanPropertyInfo where+    type AttrAllowedOps PropertyActionInvertBooleanPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PropertyActionInvertBooleanPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint PropertyActionInvertBooleanPropertyInfo = PropertyActionK+    type AttrGetType PropertyActionInvertBooleanPropertyInfo = Bool+    type AttrLabel PropertyActionInvertBooleanPropertyInfo = "PropertyAction::invert-boolean"+    attrGet _ = getPropertyActionInvertBoolean+    attrSet _ = undefined+    attrConstruct _ = constructPropertyActionInvertBoolean++-- VVV Prop "name"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getPropertyActionName :: (MonadIO m, PropertyActionK o) => o -> m T.Text+getPropertyActionName obj = liftIO $ getObjectPropertyString obj "name"++constructPropertyActionName :: T.Text -> IO ([Char], GValue)+constructPropertyActionName val = constructObjectPropertyString "name" val++data PropertyActionNamePropertyInfo+instance AttrInfo PropertyActionNamePropertyInfo where+    type AttrAllowedOps PropertyActionNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PropertyActionNamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint PropertyActionNamePropertyInfo = PropertyActionK+    type AttrGetType PropertyActionNamePropertyInfo = T.Text+    type AttrLabel PropertyActionNamePropertyInfo = "PropertyAction::name"+    attrGet _ = getPropertyActionName+    attrSet _ = undefined+    attrConstruct _ = constructPropertyActionName++-- VVV Prop "object"+   -- Type: TInterface "GObject" "Object"+   -- Flags: [PropertyWritable,PropertyConstructOnly]++constructPropertyActionObject :: (GObject.ObjectK a) => a -> IO ([Char], GValue)+constructPropertyActionObject val = constructObjectPropertyObject "object" val++data PropertyActionObjectPropertyInfo+instance AttrInfo PropertyActionObjectPropertyInfo where+    type AttrAllowedOps PropertyActionObjectPropertyInfo = '[ 'AttrConstruct]+    type AttrSetTypeConstraint PropertyActionObjectPropertyInfo = GObject.ObjectK+    type AttrBaseTypeConstraint PropertyActionObjectPropertyInfo = PropertyActionK+    type AttrGetType PropertyActionObjectPropertyInfo = ()+    type AttrLabel PropertyActionObjectPropertyInfo = "PropertyAction::object"+    attrGet _ = undefined+    attrSet _ = undefined+    attrConstruct _ = constructPropertyActionObject++-- VVV Prop "parameter-type"+   -- Type: TInterface "GLib" "VariantType"+   -- Flags: [PropertyReadable]++getPropertyActionParameterType :: (MonadIO m, PropertyActionK o) => o -> m GLib.VariantType+getPropertyActionParameterType obj = liftIO $ getObjectPropertyBoxed obj "parameter-type" GLib.VariantType++data PropertyActionParameterTypePropertyInfo+instance AttrInfo PropertyActionParameterTypePropertyInfo where+    type AttrAllowedOps PropertyActionParameterTypePropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint PropertyActionParameterTypePropertyInfo = (~) ()+    type AttrBaseTypeConstraint PropertyActionParameterTypePropertyInfo = PropertyActionK+    type AttrGetType PropertyActionParameterTypePropertyInfo = GLib.VariantType+    type AttrLabel PropertyActionParameterTypePropertyInfo = "PropertyAction::parameter-type"+    attrGet _ = getPropertyActionParameterType+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "property-name"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyWritable,PropertyConstructOnly]++constructPropertyActionPropertyName :: T.Text -> IO ([Char], GValue)+constructPropertyActionPropertyName val = constructObjectPropertyString "property-name" val++data PropertyActionPropertyNamePropertyInfo+instance AttrInfo PropertyActionPropertyNamePropertyInfo where+    type AttrAllowedOps PropertyActionPropertyNamePropertyInfo = '[ 'AttrConstruct]+    type AttrSetTypeConstraint PropertyActionPropertyNamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint PropertyActionPropertyNamePropertyInfo = PropertyActionK+    type AttrGetType PropertyActionPropertyNamePropertyInfo = ()+    type AttrLabel PropertyActionPropertyNamePropertyInfo = "PropertyAction::property-name"+    attrGet _ = undefined+    attrSet _ = undefined+    attrConstruct _ = constructPropertyActionPropertyName++-- VVV Prop "state"+   -- Type: TVariant+   -- Flags: [PropertyReadable]++getPropertyActionState :: (MonadIO m, PropertyActionK o) => o -> m GVariant+getPropertyActionState obj = liftIO $ getObjectPropertyVariant obj "state"++data PropertyActionStatePropertyInfo+instance AttrInfo PropertyActionStatePropertyInfo where+    type AttrAllowedOps PropertyActionStatePropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint PropertyActionStatePropertyInfo = (~) ()+    type AttrBaseTypeConstraint PropertyActionStatePropertyInfo = PropertyActionK+    type AttrGetType PropertyActionStatePropertyInfo = GVariant+    type AttrLabel PropertyActionStatePropertyInfo = "PropertyAction::state"+    attrGet _ = getPropertyActionState+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "state-type"+   -- Type: TInterface "GLib" "VariantType"+   -- Flags: [PropertyReadable]++getPropertyActionStateType :: (MonadIO m, PropertyActionK o) => o -> m GLib.VariantType+getPropertyActionStateType obj = liftIO $ getObjectPropertyBoxed obj "state-type" GLib.VariantType++data PropertyActionStateTypePropertyInfo+instance AttrInfo PropertyActionStateTypePropertyInfo where+    type AttrAllowedOps PropertyActionStateTypePropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint PropertyActionStateTypePropertyInfo = (~) ()+    type AttrBaseTypeConstraint PropertyActionStateTypePropertyInfo = PropertyActionK+    type AttrGetType PropertyActionStateTypePropertyInfo = GLib.VariantType+    type AttrLabel PropertyActionStateTypePropertyInfo = "PropertyAction::state-type"+    attrGet _ = getPropertyActionStateType+    attrSet _ = undefined+    attrConstruct _ = undefined++type instance AttributeList PropertyAction = PropertyActionAttributeList+type PropertyActionAttributeList = ('[ '("enabled", PropertyActionEnabledPropertyInfo), '("invert-boolean", PropertyActionInvertBooleanPropertyInfo), '("object", PropertyActionObjectPropertyInfo), '("parameter-type", PropertyActionParameterTypePropertyInfo), '("property-name", PropertyActionPropertyNamePropertyInfo), '("state", PropertyActionStatePropertyInfo), '("state-type", PropertyActionStateTypePropertyInfo)] :: [(Symbol, *)])++type instance SignalList PropertyAction = PropertyActionSignalList+type PropertyActionSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method PropertyAction::new+-- method type : Constructor+-- Args : [Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "property_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "property_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "PropertyAction"+-- throws : False+-- Skip return : False++foreign import ccall "g_property_action_new" g_property_action_new :: +    CString ->                              -- name : TBasicType TUTF8+    Ptr GObject.Object ->                   -- object : TInterface "GObject" "Object"+    CString ->                              -- property_name : TBasicType TUTF8+    IO (Ptr PropertyAction)+++propertyActionNew ::+    (MonadIO m, GObject.ObjectK a) =>+    T.Text ->                               -- name+    a ->                                    -- object+    T.Text ->                               -- property_name+    m PropertyAction+propertyActionNew name object property_name = liftIO $ do+    name' <- textToCString name+    let object' = unsafeManagedPtrCastPtr object+    property_name' <- textToCString property_name+    result <- g_property_action_new name' object' property_name'+    checkUnexpectedReturnNULL "g_property_action_new" result+    result' <- (wrapObject PropertyAction) result+    touchManagedPtr object+    freeMem name'+    freeMem property_name'+    return result'++
+ GI/Gio/Objects/PropertyAction.hs-boot view
@@ -0,0 +1,21 @@+module GI.Gio.Objects.PropertyAction where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype PropertyAction = PropertyAction (ForeignPtr PropertyAction)+instance GObject PropertyAction where+class GObject o => PropertyActionK o+instance (GObject o, IsDescendantOf PropertyAction o) => PropertyActionK o+data PropertyActionEnabledPropertyInfo+data PropertyActionInvertBooleanPropertyInfo+data PropertyActionNamePropertyInfo+data PropertyActionObjectPropertyInfo+data PropertyActionParameterTypePropertyInfo+data PropertyActionPropertyNamePropertyInfo+data PropertyActionStatePropertyInfo+data PropertyActionStateTypePropertyInfo
+ GI/Gio/Objects/ProxyAddress.hs view
@@ -0,0 +1,519 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.ProxyAddress+    ( ++-- * Exported types+    ProxyAddress(..)                        ,+    ProxyAddressK                           ,+    toProxyAddress                          ,+    noProxyAddress                          ,+++ -- * Methods+-- ** proxyAddressGetDestinationHostname+    proxyAddressGetDestinationHostname      ,+++-- ** proxyAddressGetDestinationPort+    proxyAddressGetDestinationPort          ,+++-- ** proxyAddressGetDestinationProtocol+    proxyAddressGetDestinationProtocol      ,+++-- ** proxyAddressGetPassword+    proxyAddressGetPassword                 ,+++-- ** proxyAddressGetProtocol+    proxyAddressGetProtocol                 ,+++-- ** proxyAddressGetUri+    proxyAddressGetUri                      ,+++-- ** proxyAddressGetUsername+    proxyAddressGetUsername                 ,+++-- ** proxyAddressNew+    proxyAddressNew                         ,+++++ -- * Properties+-- ** DestinationHostname+    ProxyAddressDestinationHostnamePropertyInfo,+    constructProxyAddressDestinationHostname,+    getProxyAddressDestinationHostname      ,+++-- ** DestinationPort+    ProxyAddressDestinationPortPropertyInfo ,+    constructProxyAddressDestinationPort    ,+    getProxyAddressDestinationPort          ,+++-- ** DestinationProtocol+    ProxyAddressDestinationProtocolPropertyInfo,+    constructProxyAddressDestinationProtocol,+    getProxyAddressDestinationProtocol      ,+++-- ** Password+    ProxyAddressPasswordPropertyInfo        ,+    constructProxyAddressPassword           ,+    getProxyAddressPassword                 ,+++-- ** Protocol+    ProxyAddressProtocolPropertyInfo        ,+    constructProxyAddressProtocol           ,+    getProxyAddressProtocol                 ,+++-- ** Uri+    ProxyAddressUriPropertyInfo             ,+    constructProxyAddressUri                ,+    getProxyAddressUri                      ,+++-- ** Username+    ProxyAddressUsernamePropertyInfo        ,+    constructProxyAddressUsername           ,+    getProxyAddressUsername                 ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype ProxyAddress = ProxyAddress (ForeignPtr ProxyAddress)+foreign import ccall "g_proxy_address_get_type"+    c_g_proxy_address_get_type :: IO GType++type instance ParentTypes ProxyAddress = ProxyAddressParentTypes+type ProxyAddressParentTypes = '[InetSocketAddress, SocketAddress, GObject.Object, SocketConnectable]++instance GObject ProxyAddress where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_proxy_address_get_type+    ++class GObject o => ProxyAddressK o+instance (GObject o, IsDescendantOf ProxyAddress o) => ProxyAddressK o++toProxyAddress :: ProxyAddressK o => o -> IO ProxyAddress+toProxyAddress = unsafeCastTo ProxyAddress++noProxyAddress :: Maybe ProxyAddress+noProxyAddress = Nothing++-- VVV Prop "destination-hostname"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getProxyAddressDestinationHostname :: (MonadIO m, ProxyAddressK o) => o -> m T.Text+getProxyAddressDestinationHostname obj = liftIO $ getObjectPropertyString obj "destination-hostname"++constructProxyAddressDestinationHostname :: T.Text -> IO ([Char], GValue)+constructProxyAddressDestinationHostname val = constructObjectPropertyString "destination-hostname" val++data ProxyAddressDestinationHostnamePropertyInfo+instance AttrInfo ProxyAddressDestinationHostnamePropertyInfo where+    type AttrAllowedOps ProxyAddressDestinationHostnamePropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ProxyAddressDestinationHostnamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ProxyAddressDestinationHostnamePropertyInfo = ProxyAddressK+    type AttrGetType ProxyAddressDestinationHostnamePropertyInfo = T.Text+    type AttrLabel ProxyAddressDestinationHostnamePropertyInfo = "ProxyAddress::destination-hostname"+    attrGet _ = getProxyAddressDestinationHostname+    attrSet _ = undefined+    attrConstruct _ = constructProxyAddressDestinationHostname++-- VVV Prop "destination-port"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getProxyAddressDestinationPort :: (MonadIO m, ProxyAddressK o) => o -> m Word32+getProxyAddressDestinationPort obj = liftIO $ getObjectPropertyCUInt obj "destination-port"++constructProxyAddressDestinationPort :: Word32 -> IO ([Char], GValue)+constructProxyAddressDestinationPort val = constructObjectPropertyCUInt "destination-port" val++data ProxyAddressDestinationPortPropertyInfo+instance AttrInfo ProxyAddressDestinationPortPropertyInfo where+    type AttrAllowedOps ProxyAddressDestinationPortPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ProxyAddressDestinationPortPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint ProxyAddressDestinationPortPropertyInfo = ProxyAddressK+    type AttrGetType ProxyAddressDestinationPortPropertyInfo = Word32+    type AttrLabel ProxyAddressDestinationPortPropertyInfo = "ProxyAddress::destination-port"+    attrGet _ = getProxyAddressDestinationPort+    attrSet _ = undefined+    attrConstruct _ = constructProxyAddressDestinationPort++-- VVV Prop "destination-protocol"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getProxyAddressDestinationProtocol :: (MonadIO m, ProxyAddressK o) => o -> m T.Text+getProxyAddressDestinationProtocol obj = liftIO $ getObjectPropertyString obj "destination-protocol"++constructProxyAddressDestinationProtocol :: T.Text -> IO ([Char], GValue)+constructProxyAddressDestinationProtocol val = constructObjectPropertyString "destination-protocol" val++data ProxyAddressDestinationProtocolPropertyInfo+instance AttrInfo ProxyAddressDestinationProtocolPropertyInfo where+    type AttrAllowedOps ProxyAddressDestinationProtocolPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ProxyAddressDestinationProtocolPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ProxyAddressDestinationProtocolPropertyInfo = ProxyAddressK+    type AttrGetType ProxyAddressDestinationProtocolPropertyInfo = T.Text+    type AttrLabel ProxyAddressDestinationProtocolPropertyInfo = "ProxyAddress::destination-protocol"+    attrGet _ = getProxyAddressDestinationProtocol+    attrSet _ = undefined+    attrConstruct _ = constructProxyAddressDestinationProtocol++-- VVV Prop "password"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getProxyAddressPassword :: (MonadIO m, ProxyAddressK o) => o -> m T.Text+getProxyAddressPassword obj = liftIO $ getObjectPropertyString obj "password"++constructProxyAddressPassword :: T.Text -> IO ([Char], GValue)+constructProxyAddressPassword val = constructObjectPropertyString "password" val++data ProxyAddressPasswordPropertyInfo+instance AttrInfo ProxyAddressPasswordPropertyInfo where+    type AttrAllowedOps ProxyAddressPasswordPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ProxyAddressPasswordPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ProxyAddressPasswordPropertyInfo = ProxyAddressK+    type AttrGetType ProxyAddressPasswordPropertyInfo = T.Text+    type AttrLabel ProxyAddressPasswordPropertyInfo = "ProxyAddress::password"+    attrGet _ = getProxyAddressPassword+    attrSet _ = undefined+    attrConstruct _ = constructProxyAddressPassword++-- VVV Prop "protocol"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getProxyAddressProtocol :: (MonadIO m, ProxyAddressK o) => o -> m T.Text+getProxyAddressProtocol obj = liftIO $ getObjectPropertyString obj "protocol"++constructProxyAddressProtocol :: T.Text -> IO ([Char], GValue)+constructProxyAddressProtocol val = constructObjectPropertyString "protocol" val++data ProxyAddressProtocolPropertyInfo+instance AttrInfo ProxyAddressProtocolPropertyInfo where+    type AttrAllowedOps ProxyAddressProtocolPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ProxyAddressProtocolPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ProxyAddressProtocolPropertyInfo = ProxyAddressK+    type AttrGetType ProxyAddressProtocolPropertyInfo = T.Text+    type AttrLabel ProxyAddressProtocolPropertyInfo = "ProxyAddress::protocol"+    attrGet _ = getProxyAddressProtocol+    attrSet _ = undefined+    attrConstruct _ = constructProxyAddressProtocol++-- VVV Prop "uri"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getProxyAddressUri :: (MonadIO m, ProxyAddressK o) => o -> m T.Text+getProxyAddressUri obj = liftIO $ getObjectPropertyString obj "uri"++constructProxyAddressUri :: T.Text -> IO ([Char], GValue)+constructProxyAddressUri val = constructObjectPropertyString "uri" val++data ProxyAddressUriPropertyInfo+instance AttrInfo ProxyAddressUriPropertyInfo where+    type AttrAllowedOps ProxyAddressUriPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ProxyAddressUriPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ProxyAddressUriPropertyInfo = ProxyAddressK+    type AttrGetType ProxyAddressUriPropertyInfo = T.Text+    type AttrLabel ProxyAddressUriPropertyInfo = "ProxyAddress::uri"+    attrGet _ = getProxyAddressUri+    attrSet _ = undefined+    attrConstruct _ = constructProxyAddressUri++-- VVV Prop "username"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getProxyAddressUsername :: (MonadIO m, ProxyAddressK o) => o -> m T.Text+getProxyAddressUsername obj = liftIO $ getObjectPropertyString obj "username"++constructProxyAddressUsername :: T.Text -> IO ([Char], GValue)+constructProxyAddressUsername val = constructObjectPropertyString "username" val++data ProxyAddressUsernamePropertyInfo+instance AttrInfo ProxyAddressUsernamePropertyInfo where+    type AttrAllowedOps ProxyAddressUsernamePropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ProxyAddressUsernamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ProxyAddressUsernamePropertyInfo = ProxyAddressK+    type AttrGetType ProxyAddressUsernamePropertyInfo = T.Text+    type AttrLabel ProxyAddressUsernamePropertyInfo = "ProxyAddress::username"+    attrGet _ = getProxyAddressUsername+    attrSet _ = undefined+    attrConstruct _ = constructProxyAddressUsername++type instance AttributeList ProxyAddress = ProxyAddressAttributeList+type ProxyAddressAttributeList = ('[ '("address", InetSocketAddressAddressPropertyInfo), '("destination-hostname", ProxyAddressDestinationHostnamePropertyInfo), '("destination-port", ProxyAddressDestinationPortPropertyInfo), '("destination-protocol", ProxyAddressDestinationProtocolPropertyInfo), '("family", SocketAddressFamilyPropertyInfo), '("flowinfo", InetSocketAddressFlowinfoPropertyInfo), '("password", ProxyAddressPasswordPropertyInfo), '("port", InetSocketAddressPortPropertyInfo), '("protocol", ProxyAddressProtocolPropertyInfo), '("scope-id", InetSocketAddressScopeIdPropertyInfo), '("uri", ProxyAddressUriPropertyInfo), '("username", ProxyAddressUsernamePropertyInfo)] :: [(Symbol, *)])++type instance SignalList ProxyAddress = ProxyAddressSignalList+type ProxyAddressSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method ProxyAddress::new+-- method type : Constructor+-- Args : [Arg {argName = "inetaddr", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "port", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "protocol", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "dest_hostname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "dest_port", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "username", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "password", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "inetaddr", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "port", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "protocol", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "dest_hostname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "dest_port", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "username", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "password", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "ProxyAddress"+-- throws : False+-- Skip return : False++foreign import ccall "g_proxy_address_new" g_proxy_address_new :: +    Ptr InetAddress ->                      -- inetaddr : TInterface "Gio" "InetAddress"+    Word16 ->                               -- port : TBasicType TUInt16+    CString ->                              -- protocol : TBasicType TUTF8+    CString ->                              -- dest_hostname : TBasicType TUTF8+    Word16 ->                               -- dest_port : TBasicType TUInt16+    CString ->                              -- username : TBasicType TUTF8+    CString ->                              -- password : TBasicType TUTF8+    IO (Ptr ProxyAddress)+++proxyAddressNew ::+    (MonadIO m, InetAddressK a) =>+    a ->                                    -- inetaddr+    Word16 ->                               -- port+    T.Text ->                               -- protocol+    T.Text ->                               -- dest_hostname+    Word16 ->                               -- dest_port+    Maybe (T.Text) ->                       -- username+    Maybe (T.Text) ->                       -- password+    m ProxyAddress+proxyAddressNew inetaddr port protocol dest_hostname dest_port username password = liftIO $ do+    let inetaddr' = unsafeManagedPtrCastPtr inetaddr+    protocol' <- textToCString protocol+    dest_hostname' <- textToCString dest_hostname+    maybeUsername <- case username of+        Nothing -> return nullPtr+        Just jUsername -> do+            jUsername' <- textToCString jUsername+            return jUsername'+    maybePassword <- case password of+        Nothing -> return nullPtr+        Just jPassword -> do+            jPassword' <- textToCString jPassword+            return jPassword'+    result <- g_proxy_address_new inetaddr' port protocol' dest_hostname' dest_port maybeUsername maybePassword+    checkUnexpectedReturnNULL "g_proxy_address_new" result+    result' <- (wrapObject ProxyAddress) result+    touchManagedPtr inetaddr+    freeMem protocol'+    freeMem dest_hostname'+    freeMem maybeUsername+    freeMem maybePassword+    return result'++-- method ProxyAddress::get_destination_hostname+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ProxyAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ProxyAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_proxy_address_get_destination_hostname" g_proxy_address_get_destination_hostname :: +    Ptr ProxyAddress ->                     -- _obj : TInterface "Gio" "ProxyAddress"+    IO CString+++proxyAddressGetDestinationHostname ::+    (MonadIO m, ProxyAddressK a) =>+    a ->                                    -- _obj+    m T.Text+proxyAddressGetDestinationHostname _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_proxy_address_get_destination_hostname _obj'+    checkUnexpectedReturnNULL "g_proxy_address_get_destination_hostname" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method ProxyAddress::get_destination_port+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ProxyAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ProxyAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt16+-- throws : False+-- Skip return : False++foreign import ccall "g_proxy_address_get_destination_port" g_proxy_address_get_destination_port :: +    Ptr ProxyAddress ->                     -- _obj : TInterface "Gio" "ProxyAddress"+    IO Word16+++proxyAddressGetDestinationPort ::+    (MonadIO m, ProxyAddressK a) =>+    a ->                                    -- _obj+    m Word16+proxyAddressGetDestinationPort _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_proxy_address_get_destination_port _obj'+    touchManagedPtr _obj+    return result++-- method ProxyAddress::get_destination_protocol+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ProxyAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ProxyAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_proxy_address_get_destination_protocol" g_proxy_address_get_destination_protocol :: +    Ptr ProxyAddress ->                     -- _obj : TInterface "Gio" "ProxyAddress"+    IO CString+++proxyAddressGetDestinationProtocol ::+    (MonadIO m, ProxyAddressK a) =>+    a ->                                    -- _obj+    m T.Text+proxyAddressGetDestinationProtocol _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_proxy_address_get_destination_protocol _obj'+    checkUnexpectedReturnNULL "g_proxy_address_get_destination_protocol" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method ProxyAddress::get_password+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ProxyAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ProxyAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_proxy_address_get_password" g_proxy_address_get_password :: +    Ptr ProxyAddress ->                     -- _obj : TInterface "Gio" "ProxyAddress"+    IO CString+++proxyAddressGetPassword ::+    (MonadIO m, ProxyAddressK a) =>+    a ->                                    -- _obj+    m T.Text+proxyAddressGetPassword _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_proxy_address_get_password _obj'+    checkUnexpectedReturnNULL "g_proxy_address_get_password" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method ProxyAddress::get_protocol+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ProxyAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ProxyAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_proxy_address_get_protocol" g_proxy_address_get_protocol :: +    Ptr ProxyAddress ->                     -- _obj : TInterface "Gio" "ProxyAddress"+    IO CString+++proxyAddressGetProtocol ::+    (MonadIO m, ProxyAddressK a) =>+    a ->                                    -- _obj+    m T.Text+proxyAddressGetProtocol _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_proxy_address_get_protocol _obj'+    checkUnexpectedReturnNULL "g_proxy_address_get_protocol" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method ProxyAddress::get_uri+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ProxyAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ProxyAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_proxy_address_get_uri" g_proxy_address_get_uri :: +    Ptr ProxyAddress ->                     -- _obj : TInterface "Gio" "ProxyAddress"+    IO CString+++proxyAddressGetUri ::+    (MonadIO m, ProxyAddressK a) =>+    a ->                                    -- _obj+    m T.Text+proxyAddressGetUri _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_proxy_address_get_uri _obj'+    checkUnexpectedReturnNULL "g_proxy_address_get_uri" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method ProxyAddress::get_username+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ProxyAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ProxyAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_proxy_address_get_username" g_proxy_address_get_username :: +    Ptr ProxyAddress ->                     -- _obj : TInterface "Gio" "ProxyAddress"+    IO CString+++proxyAddressGetUsername ::+    (MonadIO m, ProxyAddressK a) =>+    a ->                                    -- _obj+    m T.Text+proxyAddressGetUsername _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_proxy_address_get_username _obj'+    checkUnexpectedReturnNULL "g_proxy_address_get_username" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++
+ GI/Gio/Objects/ProxyAddress.hs-boot view
@@ -0,0 +1,20 @@+module GI.Gio.Objects.ProxyAddress where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype ProxyAddress = ProxyAddress (ForeignPtr ProxyAddress)+instance GObject ProxyAddress where+class GObject o => ProxyAddressK o+instance (GObject o, IsDescendantOf ProxyAddress o) => ProxyAddressK o+data ProxyAddressDestinationHostnamePropertyInfo+data ProxyAddressDestinationPortPropertyInfo+data ProxyAddressDestinationProtocolPropertyInfo+data ProxyAddressPasswordPropertyInfo+data ProxyAddressProtocolPropertyInfo+data ProxyAddressUriPropertyInfo+data ProxyAddressUsernamePropertyInfo
+ GI/Gio/Objects/ProxyAddressEnumerator.hs view
@@ -0,0 +1,173 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.ProxyAddressEnumerator+    ( ++-- * Exported types+    ProxyAddressEnumerator(..)              ,+    ProxyAddressEnumeratorK                 ,+    toProxyAddressEnumerator                ,+    noProxyAddressEnumerator                ,+++ -- * Properties+-- ** Connectable+    ProxyAddressEnumeratorConnectablePropertyInfo,+    constructProxyAddressEnumeratorConnectable,+    getProxyAddressEnumeratorConnectable    ,+++-- ** DefaultPort+    ProxyAddressEnumeratorDefaultPortPropertyInfo,+    constructProxyAddressEnumeratorDefaultPort,+    getProxyAddressEnumeratorDefaultPort    ,+++-- ** ProxyResolver+    ProxyAddressEnumeratorProxyResolverPropertyInfo,+    constructProxyAddressEnumeratorProxyResolver,+    getProxyAddressEnumeratorProxyResolver  ,+    setProxyAddressEnumeratorProxyResolver  ,+++-- ** Uri+    ProxyAddressEnumeratorUriPropertyInfo   ,+    constructProxyAddressEnumeratorUri      ,+    getProxyAddressEnumeratorUri            ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype ProxyAddressEnumerator = ProxyAddressEnumerator (ForeignPtr ProxyAddressEnumerator)+foreign import ccall "g_proxy_address_enumerator_get_type"+    c_g_proxy_address_enumerator_get_type :: IO GType++type instance ParentTypes ProxyAddressEnumerator = ProxyAddressEnumeratorParentTypes+type ProxyAddressEnumeratorParentTypes = '[SocketAddressEnumerator, GObject.Object]++instance GObject ProxyAddressEnumerator where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_proxy_address_enumerator_get_type+    ++class GObject o => ProxyAddressEnumeratorK o+instance (GObject o, IsDescendantOf ProxyAddressEnumerator o) => ProxyAddressEnumeratorK o++toProxyAddressEnumerator :: ProxyAddressEnumeratorK o => o -> IO ProxyAddressEnumerator+toProxyAddressEnumerator = unsafeCastTo ProxyAddressEnumerator++noProxyAddressEnumerator :: Maybe ProxyAddressEnumerator+noProxyAddressEnumerator = Nothing++-- VVV Prop "connectable"+   -- Type: TInterface "Gio" "SocketConnectable"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getProxyAddressEnumeratorConnectable :: (MonadIO m, ProxyAddressEnumeratorK o) => o -> m SocketConnectable+getProxyAddressEnumeratorConnectable obj = liftIO $ getObjectPropertyObject obj "connectable" SocketConnectable++constructProxyAddressEnumeratorConnectable :: (SocketConnectableK a) => a -> IO ([Char], GValue)+constructProxyAddressEnumeratorConnectable val = constructObjectPropertyObject "connectable" val++data ProxyAddressEnumeratorConnectablePropertyInfo+instance AttrInfo ProxyAddressEnumeratorConnectablePropertyInfo where+    type AttrAllowedOps ProxyAddressEnumeratorConnectablePropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ProxyAddressEnumeratorConnectablePropertyInfo = SocketConnectableK+    type AttrBaseTypeConstraint ProxyAddressEnumeratorConnectablePropertyInfo = ProxyAddressEnumeratorK+    type AttrGetType ProxyAddressEnumeratorConnectablePropertyInfo = SocketConnectable+    type AttrLabel ProxyAddressEnumeratorConnectablePropertyInfo = "ProxyAddressEnumerator::connectable"+    attrGet _ = getProxyAddressEnumeratorConnectable+    attrSet _ = undefined+    attrConstruct _ = constructProxyAddressEnumeratorConnectable++-- VVV Prop "default-port"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getProxyAddressEnumeratorDefaultPort :: (MonadIO m, ProxyAddressEnumeratorK o) => o -> m Word32+getProxyAddressEnumeratorDefaultPort obj = liftIO $ getObjectPropertyCUInt obj "default-port"++constructProxyAddressEnumeratorDefaultPort :: Word32 -> IO ([Char], GValue)+constructProxyAddressEnumeratorDefaultPort val = constructObjectPropertyCUInt "default-port" val++data ProxyAddressEnumeratorDefaultPortPropertyInfo+instance AttrInfo ProxyAddressEnumeratorDefaultPortPropertyInfo where+    type AttrAllowedOps ProxyAddressEnumeratorDefaultPortPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ProxyAddressEnumeratorDefaultPortPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint ProxyAddressEnumeratorDefaultPortPropertyInfo = ProxyAddressEnumeratorK+    type AttrGetType ProxyAddressEnumeratorDefaultPortPropertyInfo = Word32+    type AttrLabel ProxyAddressEnumeratorDefaultPortPropertyInfo = "ProxyAddressEnumerator::default-port"+    attrGet _ = getProxyAddressEnumeratorDefaultPort+    attrSet _ = undefined+    attrConstruct _ = constructProxyAddressEnumeratorDefaultPort++-- VVV Prop "proxy-resolver"+   -- Type: TInterface "Gio" "ProxyResolver"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getProxyAddressEnumeratorProxyResolver :: (MonadIO m, ProxyAddressEnumeratorK o) => o -> m ProxyResolver+getProxyAddressEnumeratorProxyResolver obj = liftIO $ getObjectPropertyObject obj "proxy-resolver" ProxyResolver++setProxyAddressEnumeratorProxyResolver :: (MonadIO m, ProxyAddressEnumeratorK o, ProxyResolverK a) => o -> a -> m ()+setProxyAddressEnumeratorProxyResolver obj val = liftIO $ setObjectPropertyObject obj "proxy-resolver" val++constructProxyAddressEnumeratorProxyResolver :: (ProxyResolverK a) => a -> IO ([Char], GValue)+constructProxyAddressEnumeratorProxyResolver val = constructObjectPropertyObject "proxy-resolver" val++data ProxyAddressEnumeratorProxyResolverPropertyInfo+instance AttrInfo ProxyAddressEnumeratorProxyResolverPropertyInfo where+    type AttrAllowedOps ProxyAddressEnumeratorProxyResolverPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ProxyAddressEnumeratorProxyResolverPropertyInfo = ProxyResolverK+    type AttrBaseTypeConstraint ProxyAddressEnumeratorProxyResolverPropertyInfo = ProxyAddressEnumeratorK+    type AttrGetType ProxyAddressEnumeratorProxyResolverPropertyInfo = ProxyResolver+    type AttrLabel ProxyAddressEnumeratorProxyResolverPropertyInfo = "ProxyAddressEnumerator::proxy-resolver"+    attrGet _ = getProxyAddressEnumeratorProxyResolver+    attrSet _ = setProxyAddressEnumeratorProxyResolver+    attrConstruct _ = constructProxyAddressEnumeratorProxyResolver++-- VVV Prop "uri"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getProxyAddressEnumeratorUri :: (MonadIO m, ProxyAddressEnumeratorK o) => o -> m T.Text+getProxyAddressEnumeratorUri obj = liftIO $ getObjectPropertyString obj "uri"++constructProxyAddressEnumeratorUri :: T.Text -> IO ([Char], GValue)+constructProxyAddressEnumeratorUri val = constructObjectPropertyString "uri" val++data ProxyAddressEnumeratorUriPropertyInfo+instance AttrInfo ProxyAddressEnumeratorUriPropertyInfo where+    type AttrAllowedOps ProxyAddressEnumeratorUriPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ProxyAddressEnumeratorUriPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ProxyAddressEnumeratorUriPropertyInfo = ProxyAddressEnumeratorK+    type AttrGetType ProxyAddressEnumeratorUriPropertyInfo = T.Text+    type AttrLabel ProxyAddressEnumeratorUriPropertyInfo = "ProxyAddressEnumerator::uri"+    attrGet _ = getProxyAddressEnumeratorUri+    attrSet _ = undefined+    attrConstruct _ = constructProxyAddressEnumeratorUri++type instance AttributeList ProxyAddressEnumerator = ProxyAddressEnumeratorAttributeList+type ProxyAddressEnumeratorAttributeList = ('[ '("connectable", ProxyAddressEnumeratorConnectablePropertyInfo), '("default-port", ProxyAddressEnumeratorDefaultPortPropertyInfo), '("proxy-resolver", ProxyAddressEnumeratorProxyResolverPropertyInfo), '("uri", ProxyAddressEnumeratorUriPropertyInfo)] :: [(Symbol, *)])++type instance SignalList ProxyAddressEnumerator = ProxyAddressEnumeratorSignalList+type ProxyAddressEnumeratorSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gio/Objects/ProxyAddressEnumerator.hs-boot view
@@ -0,0 +1,17 @@+module GI.Gio.Objects.ProxyAddressEnumerator where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype ProxyAddressEnumerator = ProxyAddressEnumerator (ForeignPtr ProxyAddressEnumerator)+instance GObject ProxyAddressEnumerator where+class GObject o => ProxyAddressEnumeratorK o+instance (GObject o, IsDescendantOf ProxyAddressEnumerator o) => ProxyAddressEnumeratorK o+data ProxyAddressEnumeratorConnectablePropertyInfo+data ProxyAddressEnumeratorDefaultPortPropertyInfo+data ProxyAddressEnumeratorProxyResolverPropertyInfo+data ProxyAddressEnumeratorUriPropertyInfo
+ GI/Gio/Objects/Resolver.hs view
@@ -0,0 +1,759 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.Resolver+    ( ++-- * Exported types+    Resolver(..)                            ,+    ResolverK                               ,+    toResolver                              ,+    noResolver                              ,+++ -- * Methods+-- ** resolverGetDefault+    resolverGetDefault                      ,+++-- ** resolverLookupByAddress+    resolverLookupByAddress                 ,+++-- ** resolverLookupByAddressAsync+    resolverLookupByAddressAsync            ,+++-- ** resolverLookupByAddressFinish+    resolverLookupByAddressFinish           ,+++-- ** resolverLookupByName+    resolverLookupByName                    ,+++-- ** resolverLookupByNameAsync+    resolverLookupByNameAsync               ,+++-- ** resolverLookupByNameFinish+    resolverLookupByNameFinish              ,+++-- ** resolverLookupRecords+    resolverLookupRecords                   ,+++-- ** resolverLookupRecordsAsync+    resolverLookupRecordsAsync              ,+++-- ** resolverLookupRecordsFinish+    resolverLookupRecordsFinish             ,+++-- ** resolverLookupService+    resolverLookupService                   ,+++-- ** resolverLookupServiceAsync+    resolverLookupServiceAsync              ,+++-- ** resolverLookupServiceFinish+    resolverLookupServiceFinish             ,+++-- ** resolverSetDefault+    resolverSetDefault                      ,+++++ -- * Signals+-- ** Reload+    ResolverReloadCallback                  ,+    ResolverReloadCallbackC                 ,+    ResolverReloadSignalInfo                ,+    afterResolverReload                     ,+    mkResolverReloadCallback                ,+    noResolverReloadCallback                ,+    onResolverReload                        ,+    resolverReloadCallbackWrapper           ,+    resolverReloadClosure                   ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype Resolver = Resolver (ForeignPtr Resolver)+foreign import ccall "g_resolver_get_type"+    c_g_resolver_get_type :: IO GType++type instance ParentTypes Resolver = ResolverParentTypes+type ResolverParentTypes = '[GObject.Object]++instance GObject Resolver where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_resolver_get_type+    ++class GObject o => ResolverK o+instance (GObject o, IsDescendantOf Resolver o) => ResolverK o++toResolver :: ResolverK o => o -> IO Resolver+toResolver = unsafeCastTo Resolver++noResolver :: Maybe Resolver+noResolver = Nothing++-- signal Resolver::reload+type ResolverReloadCallback =+    IO ()++noResolverReloadCallback :: Maybe ResolverReloadCallback+noResolverReloadCallback = Nothing++type ResolverReloadCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkResolverReloadCallback :: ResolverReloadCallbackC -> IO (FunPtr ResolverReloadCallbackC)++resolverReloadClosure :: ResolverReloadCallback -> IO Closure+resolverReloadClosure cb = newCClosure =<< mkResolverReloadCallback wrapped+    where wrapped = resolverReloadCallbackWrapper cb++resolverReloadCallbackWrapper ::+    ResolverReloadCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+resolverReloadCallbackWrapper _cb _ _ = do+    _cb ++onResolverReload :: (GObject a, MonadIO m) => a -> ResolverReloadCallback -> m SignalHandlerId+onResolverReload obj cb = liftIO $ connectResolverReload obj cb SignalConnectBefore+afterResolverReload :: (GObject a, MonadIO m) => a -> ResolverReloadCallback -> m SignalHandlerId+afterResolverReload obj cb = connectResolverReload obj cb SignalConnectAfter++connectResolverReload :: (GObject a, MonadIO m) =>+                         a -> ResolverReloadCallback -> SignalConnectMode -> m SignalHandlerId+connectResolverReload obj cb after = liftIO $ do+    cb' <- mkResolverReloadCallback (resolverReloadCallbackWrapper cb)+    connectSignalFunPtr obj "reload" cb' after++type instance AttributeList Resolver = ResolverAttributeList+type ResolverAttributeList = ('[ ] :: [(Symbol, *)])++data ResolverReloadSignalInfo+instance SignalInfo ResolverReloadSignalInfo where+    type HaskellCallbackType ResolverReloadSignalInfo = ResolverReloadCallback+    connectSignal _ = connectResolverReload++type instance SignalList Resolver = ResolverSignalList+type ResolverSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("reload", ResolverReloadSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Resolver::lookup_by_address+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Resolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "address", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Resolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "address", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : True+-- Skip return : False++foreign import ccall "g_resolver_lookup_by_address" g_resolver_lookup_by_address :: +    Ptr Resolver ->                         -- _obj : TInterface "Gio" "Resolver"+    Ptr InetAddress ->                      -- address : TInterface "Gio" "InetAddress"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CString+++resolverLookupByAddress ::+    (MonadIO m, ResolverK a, InetAddressK b, CancellableK c) =>+    a ->                                    -- _obj+    b ->                                    -- address+    Maybe (c) ->                            -- cancellable+    m T.Text+resolverLookupByAddress _obj address cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let address' = unsafeManagedPtrCastPtr address+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_resolver_lookup_by_address _obj' address' maybeCancellable+        checkUnexpectedReturnNULL "g_resolver_lookup_by_address" result+        result' <- cstringToText result+        freeMem result+        touchManagedPtr _obj+        touchManagedPtr address+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )++-- method Resolver::lookup_by_address_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Resolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "address", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Resolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "address", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_resolver_lookup_by_address_async" g_resolver_lookup_by_address_async :: +    Ptr Resolver ->                         -- _obj : TInterface "Gio" "Resolver"+    Ptr InetAddress ->                      -- address : TInterface "Gio" "InetAddress"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++resolverLookupByAddressAsync ::+    (MonadIO m, ResolverK a, InetAddressK b, CancellableK c) =>+    a ->                                    -- _obj+    b ->                                    -- address+    Maybe (c) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+resolverLookupByAddressAsync _obj address cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let address' = unsafeManagedPtrCastPtr address+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_resolver_lookup_by_address_async _obj' address' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    touchManagedPtr address+    whenJust cancellable touchManagedPtr+    return ()++-- method Resolver::lookup_by_address_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Resolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Resolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : True+-- Skip return : False++foreign import ccall "g_resolver_lookup_by_address_finish" g_resolver_lookup_by_address_finish :: +    Ptr Resolver ->                         -- _obj : TInterface "Gio" "Resolver"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CString+++resolverLookupByAddressFinish ::+    (MonadIO m, ResolverK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m T.Text+resolverLookupByAddressFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        result <- propagateGError $ g_resolver_lookup_by_address_finish _obj' result_'+        checkUnexpectedReturnNULL "g_resolver_lookup_by_address_finish" result+        result' <- cstringToText result+        freeMem result+        touchManagedPtr _obj+        touchManagedPtr result_+        return result'+     ) (do+        return ()+     )++-- method Resolver::lookup_by_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Resolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "hostname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Resolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "hostname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gio" "InetAddress")+-- throws : True+-- Skip return : False++foreign import ccall "g_resolver_lookup_by_name" g_resolver_lookup_by_name :: +    Ptr Resolver ->                         -- _obj : TInterface "Gio" "Resolver"+    CString ->                              -- hostname : TBasicType TUTF8+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr (GList (Ptr InetAddress)))+++resolverLookupByName ::+    (MonadIO m, ResolverK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- hostname+    Maybe (b) ->                            -- cancellable+    m [InetAddress]+resolverLookupByName _obj hostname cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    hostname' <- textToCString hostname+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_resolver_lookup_by_name _obj' hostname' maybeCancellable+        checkUnexpectedReturnNULL "g_resolver_lookup_by_name" result+        result' <- unpackGList result+        result'' <- mapM (wrapObject InetAddress) result'+        g_list_free result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem hostname'+        return result''+     ) (do+        freeMem hostname'+     )++-- method Resolver::lookup_by_name_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Resolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "hostname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Resolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "hostname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_resolver_lookup_by_name_async" g_resolver_lookup_by_name_async :: +    Ptr Resolver ->                         -- _obj : TInterface "Gio" "Resolver"+    CString ->                              -- hostname : TBasicType TUTF8+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++resolverLookupByNameAsync ::+    (MonadIO m, ResolverK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- hostname+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+resolverLookupByNameAsync _obj hostname cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    hostname' <- textToCString hostname+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_resolver_lookup_by_name_async _obj' hostname' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    freeMem hostname'+    return ()++-- method Resolver::lookup_by_name_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Resolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Resolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gio" "InetAddress")+-- throws : True+-- Skip return : False++foreign import ccall "g_resolver_lookup_by_name_finish" g_resolver_lookup_by_name_finish :: +    Ptr Resolver ->                         -- _obj : TInterface "Gio" "Resolver"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr (GList (Ptr InetAddress)))+++resolverLookupByNameFinish ::+    (MonadIO m, ResolverK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m [InetAddress]+resolverLookupByNameFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        result <- propagateGError $ g_resolver_lookup_by_name_finish _obj' result_'+        checkUnexpectedReturnNULL "g_resolver_lookup_by_name_finish" result+        result' <- unpackGList result+        result'' <- mapM (wrapObject InetAddress) result'+        g_list_free result+        touchManagedPtr _obj+        touchManagedPtr result_+        return result''+     ) (do+        return ()+     )++-- method Resolver::lookup_records+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Resolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rrname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "record_type", argType = TInterface "Gio" "ResolverRecordType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Resolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rrname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "record_type", argType = TInterface "Gio" "ResolverRecordType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList TVariant+-- throws : True+-- Skip return : False++foreign import ccall "g_resolver_lookup_records" g_resolver_lookup_records :: +    Ptr Resolver ->                         -- _obj : TInterface "Gio" "Resolver"+    CString ->                              -- rrname : TBasicType TUTF8+    CUInt ->                                -- record_type : TInterface "Gio" "ResolverRecordType"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr (GList (Ptr GVariant)))+++resolverLookupRecords ::+    (MonadIO m, ResolverK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- rrname+    ResolverRecordType ->                   -- record_type+    Maybe (b) ->                            -- cancellable+    m [GVariant]+resolverLookupRecords _obj rrname record_type cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    rrname' <- textToCString rrname+    let record_type' = (fromIntegral . fromEnum) record_type+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_resolver_lookup_records _obj' rrname' record_type' maybeCancellable+        checkUnexpectedReturnNULL "g_resolver_lookup_records" result+        result' <- unpackGList result+        result'' <- mapM wrapGVariantPtr result'+        g_list_free result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem rrname'+        return result''+     ) (do+        freeMem rrname'+     )++-- method Resolver::lookup_records_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Resolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rrname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "record_type", argType = TInterface "Gio" "ResolverRecordType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Resolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rrname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "record_type", argType = TInterface "Gio" "ResolverRecordType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_resolver_lookup_records_async" g_resolver_lookup_records_async :: +    Ptr Resolver ->                         -- _obj : TInterface "Gio" "Resolver"+    CString ->                              -- rrname : TBasicType TUTF8+    CUInt ->                                -- record_type : TInterface "Gio" "ResolverRecordType"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++resolverLookupRecordsAsync ::+    (MonadIO m, ResolverK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- rrname+    ResolverRecordType ->                   -- record_type+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+resolverLookupRecordsAsync _obj rrname record_type cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    rrname' <- textToCString rrname+    let record_type' = (fromIntegral . fromEnum) record_type+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_resolver_lookup_records_async _obj' rrname' record_type' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    freeMem rrname'+    return ()++-- method Resolver::lookup_records_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Resolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Resolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList TVariant+-- throws : True+-- Skip return : False++foreign import ccall "g_resolver_lookup_records_finish" g_resolver_lookup_records_finish :: +    Ptr Resolver ->                         -- _obj : TInterface "Gio" "Resolver"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr (GList (Ptr GVariant)))+++resolverLookupRecordsFinish ::+    (MonadIO m, ResolverK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m [GVariant]+resolverLookupRecordsFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        result <- propagateGError $ g_resolver_lookup_records_finish _obj' result_'+        checkUnexpectedReturnNULL "g_resolver_lookup_records_finish" result+        result' <- unpackGList result+        result'' <- mapM wrapGVariantPtr result'+        g_list_free result+        touchManagedPtr _obj+        touchManagedPtr result_+        return result''+     ) (do+        return ()+     )++-- method Resolver::lookup_service+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Resolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "service", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "protocol", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "domain", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Resolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "service", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "protocol", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "domain", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gio" "SrvTarget")+-- throws : True+-- Skip return : False++foreign import ccall "g_resolver_lookup_service" g_resolver_lookup_service :: +    Ptr Resolver ->                         -- _obj : TInterface "Gio" "Resolver"+    CString ->                              -- service : TBasicType TUTF8+    CString ->                              -- protocol : TBasicType TUTF8+    CString ->                              -- domain : TBasicType TUTF8+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr (GList (Ptr SrvTarget)))+++resolverLookupService ::+    (MonadIO m, ResolverK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- service+    T.Text ->                               -- protocol+    T.Text ->                               -- domain+    Maybe (b) ->                            -- cancellable+    m [SrvTarget]+resolverLookupService _obj service protocol domain cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    service' <- textToCString service+    protocol' <- textToCString protocol+    domain' <- textToCString domain+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_resolver_lookup_service _obj' service' protocol' domain' maybeCancellable+        checkUnexpectedReturnNULL "g_resolver_lookup_service" result+        result' <- unpackGList result+        result'' <- mapM (wrapBoxed SrvTarget) result'+        g_list_free result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem service'+        freeMem protocol'+        freeMem domain'+        return result''+     ) (do+        freeMem service'+        freeMem protocol'+        freeMem domain'+     )++-- method Resolver::lookup_service_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Resolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "service", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "protocol", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "domain", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Resolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "service", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "protocol", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "domain", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_resolver_lookup_service_async" g_resolver_lookup_service_async :: +    Ptr Resolver ->                         -- _obj : TInterface "Gio" "Resolver"+    CString ->                              -- service : TBasicType TUTF8+    CString ->                              -- protocol : TBasicType TUTF8+    CString ->                              -- domain : TBasicType TUTF8+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++resolverLookupServiceAsync ::+    (MonadIO m, ResolverK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- service+    T.Text ->                               -- protocol+    T.Text ->                               -- domain+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+resolverLookupServiceAsync _obj service protocol domain cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    service' <- textToCString service+    protocol' <- textToCString protocol+    domain' <- textToCString domain+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_resolver_lookup_service_async _obj' service' protocol' domain' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    freeMem service'+    freeMem protocol'+    freeMem domain'+    return ()++-- method Resolver::lookup_service_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Resolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Resolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gio" "SrvTarget")+-- throws : True+-- Skip return : False++foreign import ccall "g_resolver_lookup_service_finish" g_resolver_lookup_service_finish :: +    Ptr Resolver ->                         -- _obj : TInterface "Gio" "Resolver"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr (GList (Ptr SrvTarget)))+++resolverLookupServiceFinish ::+    (MonadIO m, ResolverK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m [SrvTarget]+resolverLookupServiceFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        result <- propagateGError $ g_resolver_lookup_service_finish _obj' result_'+        checkUnexpectedReturnNULL "g_resolver_lookup_service_finish" result+        result' <- unpackGList result+        result'' <- mapM (wrapBoxed SrvTarget) result'+        g_list_free result+        touchManagedPtr _obj+        touchManagedPtr result_+        return result''+     ) (do+        return ()+     )++-- method Resolver::set_default+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Resolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Resolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_resolver_set_default" g_resolver_set_default :: +    Ptr Resolver ->                         -- _obj : TInterface "Gio" "Resolver"+    IO ()+++resolverSetDefault ::+    (MonadIO m, ResolverK a) =>+    a ->                                    -- _obj+    m ()+resolverSetDefault _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_resolver_set_default _obj'+    touchManagedPtr _obj+    return ()++-- method Resolver::get_default+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gio" "Resolver"+-- throws : False+-- Skip return : False++foreign import ccall "g_resolver_get_default" g_resolver_get_default :: +    IO (Ptr Resolver)+++resolverGetDefault ::+    (MonadIO m) =>+    m Resolver+resolverGetDefault  = liftIO $ do+    result <- g_resolver_get_default+    checkUnexpectedReturnNULL "g_resolver_get_default" result+    result' <- (wrapObject Resolver) result+    return result'++
+ GI/Gio/Objects/Resolver.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gio.Objects.Resolver where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Resolver = Resolver (ForeignPtr Resolver)+instance GObject Resolver where+class GObject o => ResolverK o+instance (GObject o, IsDescendantOf Resolver o) => ResolverK o+data ResolverReloadSignalInfo
+ GI/Gio/Objects/Settings.hs view
@@ -0,0 +1,1955 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.Settings+    ( ++-- * Exported types+    Settings(..)                            ,+    SettingsK                               ,+    toSettings                              ,+    noSettings                              ,+++ -- * Methods+-- ** settingsApply+    settingsApply                           ,+++-- ** settingsBind+    settingsBind                            ,+++-- ** settingsBindWritable+    settingsBindWritable                    ,+++-- ** settingsCreateAction+    settingsCreateAction                    ,+++-- ** settingsDelay+    settingsDelay                           ,+++-- ** settingsGetBoolean+    settingsGetBoolean                      ,+++-- ** settingsGetChild+    settingsGetChild                        ,+++-- ** settingsGetDefaultValue+    settingsGetDefaultValue                 ,+++-- ** settingsGetDouble+    settingsGetDouble                       ,+++-- ** settingsGetEnum+    settingsGetEnum                         ,+++-- ** settingsGetFlags+    settingsGetFlags                        ,+++-- ** settingsGetHasUnapplied+    settingsGetHasUnapplied                 ,+++-- ** settingsGetInt+    settingsGetInt                          ,+++-- ** settingsGetMapped+    settingsGetMapped                       ,+++-- ** settingsGetRange+    settingsGetRange                        ,+++-- ** settingsGetString+    settingsGetString                       ,+++-- ** settingsGetStrv+    settingsGetStrv                         ,+++-- ** settingsGetUint+    settingsGetUint                         ,+++-- ** settingsGetUserValue+    settingsGetUserValue                    ,+++-- ** settingsGetValue+    settingsGetValue                        ,+++-- ** settingsIsWritable+    settingsIsWritable                      ,+++-- ** settingsListChildren+    settingsListChildren                    ,+++-- ** settingsListKeys+    settingsListKeys                        ,+++-- ** settingsListRelocatableSchemas+    settingsListRelocatableSchemas          ,+++-- ** settingsListSchemas+    settingsListSchemas                     ,+++-- ** settingsNew+    settingsNew                             ,+++-- ** settingsNewFull+    settingsNewFull                         ,+++-- ** settingsNewWithBackend+    settingsNewWithBackend                  ,+++-- ** settingsNewWithBackendAndPath+    settingsNewWithBackendAndPath           ,+++-- ** settingsNewWithPath+    settingsNewWithPath                     ,+++-- ** settingsRangeCheck+    settingsRangeCheck                      ,+++-- ** settingsReset+    settingsReset                           ,+++-- ** settingsRevert+    settingsRevert                          ,+++-- ** settingsSetBoolean+    settingsSetBoolean                      ,+++-- ** settingsSetDouble+    settingsSetDouble                       ,+++-- ** settingsSetEnum+    settingsSetEnum                         ,+++-- ** settingsSetFlags+    settingsSetFlags                        ,+++-- ** settingsSetInt+    settingsSetInt                          ,+++-- ** settingsSetString+    settingsSetString                       ,+++-- ** settingsSetStrv+    settingsSetStrv                         ,+++-- ** settingsSetUint+    settingsSetUint                         ,+++-- ** settingsSetValue+    settingsSetValue                        ,+++-- ** settingsSync+    settingsSync                            ,+++-- ** settingsUnbind+    settingsUnbind                          ,+++++ -- * Properties+-- ** DelayApply+    SettingsDelayApplyPropertyInfo          ,+    getSettingsDelayApply                   ,+++-- ** HasUnapplied+    SettingsHasUnappliedPropertyInfo        ,+    getSettingsHasUnapplied                 ,+++-- ** Path+    SettingsPathPropertyInfo                ,+    constructSettingsPath                   ,+    getSettingsPath                         ,+++-- ** Schema+    SettingsSchemaPropertyInfo              ,+    constructSettingsSchema                 ,+    getSettingsSchema                       ,+++-- ** SchemaId+    SettingsSchemaIdPropertyInfo            ,+    constructSettingsSchemaId               ,+    getSettingsSchemaId                     ,+++-- ** SettingsSchema+    SettingsSettingsSchemaPropertyInfo      ,+    constructSettingsSettingsSchema         ,+    getSettingsSettingsSchema               ,+++++ -- * Signals+-- ** ChangeEvent+    SettingsChangeEventCallback             ,+    SettingsChangeEventCallbackC            ,+    SettingsChangeEventSignalInfo           ,+    afterSettingsChangeEvent                ,+    mkSettingsChangeEventCallback           ,+    noSettingsChangeEventCallback           ,+    onSettingsChangeEvent                   ,+    settingsChangeEventCallbackWrapper      ,+    settingsChangeEventClosure              ,+++-- ** Changed+    SettingsChangedCallback                 ,+    SettingsChangedCallbackC                ,+    SettingsChangedSignalInfo               ,+    afterSettingsChanged                    ,+    mkSettingsChangedCallback               ,+    noSettingsChangedCallback               ,+    onSettingsChanged                       ,+    settingsChangedCallbackWrapper          ,+    settingsChangedClosure                  ,+++-- ** WritableChangeEvent+    SettingsWritableChangeEventCallback     ,+    SettingsWritableChangeEventCallbackC    ,+    SettingsWritableChangeEventSignalInfo   ,+    afterSettingsWritableChangeEvent        ,+    mkSettingsWritableChangeEventCallback   ,+    noSettingsWritableChangeEventCallback   ,+    onSettingsWritableChangeEvent           ,+    settingsWritableChangeEventCallbackWrapper,+    settingsWritableChangeEventClosure      ,+++-- ** WritableChanged+    SettingsWritableChangedCallback         ,+    SettingsWritableChangedCallbackC        ,+    SettingsWritableChangedSignalInfo       ,+    afterSettingsWritableChanged            ,+    mkSettingsWritableChangedCallback       ,+    noSettingsWritableChangedCallback       ,+    onSettingsWritableChanged               ,+    settingsWritableChangedCallbackWrapper  ,+    settingsWritableChangedClosure          ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype Settings = Settings (ForeignPtr Settings)+foreign import ccall "g_settings_get_type"+    c_g_settings_get_type :: IO GType++type instance ParentTypes Settings = SettingsParentTypes+type SettingsParentTypes = '[GObject.Object]++instance GObject Settings where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_settings_get_type+    ++class GObject o => SettingsK o+instance (GObject o, IsDescendantOf Settings o) => SettingsK o++toSettings :: SettingsK o => o -> IO Settings+toSettings = unsafeCastTo Settings++noSettings :: Maybe Settings+noSettings = Nothing++-- signal Settings::change-event+type SettingsChangeEventCallback =+    Maybe [Word32] ->+    IO Bool++noSettingsChangeEventCallback :: Maybe SettingsChangeEventCallback+noSettingsChangeEventCallback = Nothing++type SettingsChangeEventCallbackC =+    Ptr () ->                               -- object+    Ptr Word32 ->+    Int32 ->+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkSettingsChangeEventCallback :: SettingsChangeEventCallbackC -> IO (FunPtr SettingsChangeEventCallbackC)++settingsChangeEventClosure :: SettingsChangeEventCallback -> IO Closure+settingsChangeEventClosure cb = newCClosure =<< mkSettingsChangeEventCallback wrapped+    where wrapped = settingsChangeEventCallbackWrapper cb++settingsChangeEventCallbackWrapper ::+    SettingsChangeEventCallback ->+    Ptr () ->+    Ptr Word32 ->+    Int32 ->+    Ptr () ->+    IO CInt+settingsChangeEventCallbackWrapper _cb _ keys n_keys _ = do+    maybeKeys <-+        if keys == nullPtr+        then return Nothing+        else do+            keys' <- (unpackStorableArrayWithLength n_keys) keys+            return $ Just keys'+    result <- _cb  maybeKeys+    let result' = (fromIntegral . fromEnum) result+    return result'++onSettingsChangeEvent :: (GObject a, MonadIO m) => a -> SettingsChangeEventCallback -> m SignalHandlerId+onSettingsChangeEvent obj cb = liftIO $ connectSettingsChangeEvent obj cb SignalConnectBefore+afterSettingsChangeEvent :: (GObject a, MonadIO m) => a -> SettingsChangeEventCallback -> m SignalHandlerId+afterSettingsChangeEvent obj cb = connectSettingsChangeEvent obj cb SignalConnectAfter++connectSettingsChangeEvent :: (GObject a, MonadIO m) =>+                              a -> SettingsChangeEventCallback -> SignalConnectMode -> m SignalHandlerId+connectSettingsChangeEvent obj cb after = liftIO $ do+    cb' <- mkSettingsChangeEventCallback (settingsChangeEventCallbackWrapper cb)+    connectSignalFunPtr obj "change-event" cb' after++-- signal Settings::changed+type SettingsChangedCallback =+    T.Text ->+    IO ()++noSettingsChangedCallback :: Maybe SettingsChangedCallback+noSettingsChangedCallback = Nothing++type SettingsChangedCallbackC =+    Ptr () ->                               -- object+    CString ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkSettingsChangedCallback :: SettingsChangedCallbackC -> IO (FunPtr SettingsChangedCallbackC)++settingsChangedClosure :: SettingsChangedCallback -> IO Closure+settingsChangedClosure cb = newCClosure =<< mkSettingsChangedCallback wrapped+    where wrapped = settingsChangedCallbackWrapper cb++settingsChangedCallbackWrapper ::+    SettingsChangedCallback ->+    Ptr () ->+    CString ->+    Ptr () ->+    IO ()+settingsChangedCallbackWrapper _cb _ key _ = do+    key' <- cstringToText key+    _cb  key'++onSettingsChanged :: (GObject a, MonadIO m) => a -> SettingsChangedCallback -> m SignalHandlerId+onSettingsChanged obj cb = liftIO $ connectSettingsChanged obj cb SignalConnectBefore+afterSettingsChanged :: (GObject a, MonadIO m) => a -> SettingsChangedCallback -> m SignalHandlerId+afterSettingsChanged obj cb = connectSettingsChanged obj cb SignalConnectAfter++connectSettingsChanged :: (GObject a, MonadIO m) =>+                          a -> SettingsChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectSettingsChanged obj cb after = liftIO $ do+    cb' <- mkSettingsChangedCallback (settingsChangedCallbackWrapper cb)+    connectSignalFunPtr obj "changed" cb' after++-- signal Settings::writable-change-event+type SettingsWritableChangeEventCallback =+    Word32 ->+    IO Bool++noSettingsWritableChangeEventCallback :: Maybe SettingsWritableChangeEventCallback+noSettingsWritableChangeEventCallback = Nothing++type SettingsWritableChangeEventCallbackC =+    Ptr () ->                               -- object+    Word32 ->+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkSettingsWritableChangeEventCallback :: SettingsWritableChangeEventCallbackC -> IO (FunPtr SettingsWritableChangeEventCallbackC)++settingsWritableChangeEventClosure :: SettingsWritableChangeEventCallback -> IO Closure+settingsWritableChangeEventClosure cb = newCClosure =<< mkSettingsWritableChangeEventCallback wrapped+    where wrapped = settingsWritableChangeEventCallbackWrapper cb++settingsWritableChangeEventCallbackWrapper ::+    SettingsWritableChangeEventCallback ->+    Ptr () ->+    Word32 ->+    Ptr () ->+    IO CInt+settingsWritableChangeEventCallbackWrapper _cb _ key _ = do+    result <- _cb  key+    let result' = (fromIntegral . fromEnum) result+    return result'++onSettingsWritableChangeEvent :: (GObject a, MonadIO m) => a -> SettingsWritableChangeEventCallback -> m SignalHandlerId+onSettingsWritableChangeEvent obj cb = liftIO $ connectSettingsWritableChangeEvent obj cb SignalConnectBefore+afterSettingsWritableChangeEvent :: (GObject a, MonadIO m) => a -> SettingsWritableChangeEventCallback -> m SignalHandlerId+afterSettingsWritableChangeEvent obj cb = connectSettingsWritableChangeEvent obj cb SignalConnectAfter++connectSettingsWritableChangeEvent :: (GObject a, MonadIO m) =>+                                      a -> SettingsWritableChangeEventCallback -> SignalConnectMode -> m SignalHandlerId+connectSettingsWritableChangeEvent obj cb after = liftIO $ do+    cb' <- mkSettingsWritableChangeEventCallback (settingsWritableChangeEventCallbackWrapper cb)+    connectSignalFunPtr obj "writable-change-event" cb' after++-- signal Settings::writable-changed+type SettingsWritableChangedCallback =+    T.Text ->+    IO ()++noSettingsWritableChangedCallback :: Maybe SettingsWritableChangedCallback+noSettingsWritableChangedCallback = Nothing++type SettingsWritableChangedCallbackC =+    Ptr () ->                               -- object+    CString ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkSettingsWritableChangedCallback :: SettingsWritableChangedCallbackC -> IO (FunPtr SettingsWritableChangedCallbackC)++settingsWritableChangedClosure :: SettingsWritableChangedCallback -> IO Closure+settingsWritableChangedClosure cb = newCClosure =<< mkSettingsWritableChangedCallback wrapped+    where wrapped = settingsWritableChangedCallbackWrapper cb++settingsWritableChangedCallbackWrapper ::+    SettingsWritableChangedCallback ->+    Ptr () ->+    CString ->+    Ptr () ->+    IO ()+settingsWritableChangedCallbackWrapper _cb _ key _ = do+    key' <- cstringToText key+    _cb  key'++onSettingsWritableChanged :: (GObject a, MonadIO m) => a -> SettingsWritableChangedCallback -> m SignalHandlerId+onSettingsWritableChanged obj cb = liftIO $ connectSettingsWritableChanged obj cb SignalConnectBefore+afterSettingsWritableChanged :: (GObject a, MonadIO m) => a -> SettingsWritableChangedCallback -> m SignalHandlerId+afterSettingsWritableChanged obj cb = connectSettingsWritableChanged obj cb SignalConnectAfter++connectSettingsWritableChanged :: (GObject a, MonadIO m) =>+                                  a -> SettingsWritableChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectSettingsWritableChanged obj cb after = liftIO $ do+    cb' <- mkSettingsWritableChangedCallback (settingsWritableChangedCallbackWrapper cb)+    connectSignalFunPtr obj "writable-changed" cb' after++-- VVV Prop "delay-apply"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getSettingsDelayApply :: (MonadIO m, SettingsK o) => o -> m Bool+getSettingsDelayApply obj = liftIO $ getObjectPropertyBool obj "delay-apply"++data SettingsDelayApplyPropertyInfo+instance AttrInfo SettingsDelayApplyPropertyInfo where+    type AttrAllowedOps SettingsDelayApplyPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint SettingsDelayApplyPropertyInfo = (~) ()+    type AttrBaseTypeConstraint SettingsDelayApplyPropertyInfo = SettingsK+    type AttrGetType SettingsDelayApplyPropertyInfo = Bool+    type AttrLabel SettingsDelayApplyPropertyInfo = "Settings::delay-apply"+    attrGet _ = getSettingsDelayApply+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "has-unapplied"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getSettingsHasUnapplied :: (MonadIO m, SettingsK o) => o -> m Bool+getSettingsHasUnapplied obj = liftIO $ getObjectPropertyBool obj "has-unapplied"++data SettingsHasUnappliedPropertyInfo+instance AttrInfo SettingsHasUnappliedPropertyInfo where+    type AttrAllowedOps SettingsHasUnappliedPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint SettingsHasUnappliedPropertyInfo = (~) ()+    type AttrBaseTypeConstraint SettingsHasUnappliedPropertyInfo = SettingsK+    type AttrGetType SettingsHasUnappliedPropertyInfo = Bool+    type AttrLabel SettingsHasUnappliedPropertyInfo = "Settings::has-unapplied"+    attrGet _ = getSettingsHasUnapplied+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "path"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getSettingsPath :: (MonadIO m, SettingsK o) => o -> m T.Text+getSettingsPath obj = liftIO $ getObjectPropertyString obj "path"++constructSettingsPath :: T.Text -> IO ([Char], GValue)+constructSettingsPath val = constructObjectPropertyString "path" val++data SettingsPathPropertyInfo+instance AttrInfo SettingsPathPropertyInfo where+    type AttrAllowedOps SettingsPathPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SettingsPathPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint SettingsPathPropertyInfo = SettingsK+    type AttrGetType SettingsPathPropertyInfo = T.Text+    type AttrLabel SettingsPathPropertyInfo = "Settings::path"+    attrGet _ = getSettingsPath+    attrSet _ = undefined+    attrConstruct _ = constructSettingsPath++-- VVV Prop "schema"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getSettingsSchema :: (MonadIO m, SettingsK o) => o -> m T.Text+getSettingsSchema obj = liftIO $ getObjectPropertyString obj "schema"++constructSettingsSchema :: T.Text -> IO ([Char], GValue)+constructSettingsSchema val = constructObjectPropertyString "schema" val++data SettingsSchemaPropertyInfo+instance AttrInfo SettingsSchemaPropertyInfo where+    type AttrAllowedOps SettingsSchemaPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SettingsSchemaPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint SettingsSchemaPropertyInfo = SettingsK+    type AttrGetType SettingsSchemaPropertyInfo = T.Text+    type AttrLabel SettingsSchemaPropertyInfo = "Settings::schema"+    attrGet _ = getSettingsSchema+    attrSet _ = undefined+    attrConstruct _ = constructSettingsSchema++-- VVV Prop "schema-id"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getSettingsSchemaId :: (MonadIO m, SettingsK o) => o -> m T.Text+getSettingsSchemaId obj = liftIO $ getObjectPropertyString obj "schema-id"++constructSettingsSchemaId :: T.Text -> IO ([Char], GValue)+constructSettingsSchemaId val = constructObjectPropertyString "schema-id" val++data SettingsSchemaIdPropertyInfo+instance AttrInfo SettingsSchemaIdPropertyInfo where+    type AttrAllowedOps SettingsSchemaIdPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SettingsSchemaIdPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint SettingsSchemaIdPropertyInfo = SettingsK+    type AttrGetType SettingsSchemaIdPropertyInfo = T.Text+    type AttrLabel SettingsSchemaIdPropertyInfo = "Settings::schema-id"+    attrGet _ = getSettingsSchemaId+    attrSet _ = undefined+    attrConstruct _ = constructSettingsSchemaId++-- VVV Prop "settings-schema"+   -- Type: TInterface "Gio" "SettingsSchema"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getSettingsSettingsSchema :: (MonadIO m, SettingsK o) => o -> m SettingsSchema+getSettingsSettingsSchema obj = liftIO $ getObjectPropertyBoxed obj "settings-schema" SettingsSchema++constructSettingsSettingsSchema :: SettingsSchema -> IO ([Char], GValue)+constructSettingsSettingsSchema val = constructObjectPropertyBoxed "settings-schema" val++data SettingsSettingsSchemaPropertyInfo+instance AttrInfo SettingsSettingsSchemaPropertyInfo where+    type AttrAllowedOps SettingsSettingsSchemaPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SettingsSettingsSchemaPropertyInfo = (~) SettingsSchema+    type AttrBaseTypeConstraint SettingsSettingsSchemaPropertyInfo = SettingsK+    type AttrGetType SettingsSettingsSchemaPropertyInfo = SettingsSchema+    type AttrLabel SettingsSettingsSchemaPropertyInfo = "Settings::settings-schema"+    attrGet _ = getSettingsSettingsSchema+    attrSet _ = undefined+    attrConstruct _ = constructSettingsSettingsSchema++type instance AttributeList Settings = SettingsAttributeList+type SettingsAttributeList = ('[ '("delay-apply", SettingsDelayApplyPropertyInfo), '("has-unapplied", SettingsHasUnappliedPropertyInfo), '("path", SettingsPathPropertyInfo), '("schema", SettingsSchemaPropertyInfo), '("schema-id", SettingsSchemaIdPropertyInfo), '("settings-schema", SettingsSettingsSchemaPropertyInfo)] :: [(Symbol, *)])++data SettingsChangeEventSignalInfo+instance SignalInfo SettingsChangeEventSignalInfo where+    type HaskellCallbackType SettingsChangeEventSignalInfo = SettingsChangeEventCallback+    connectSignal _ = connectSettingsChangeEvent++data SettingsChangedSignalInfo+instance SignalInfo SettingsChangedSignalInfo where+    type HaskellCallbackType SettingsChangedSignalInfo = SettingsChangedCallback+    connectSignal _ = connectSettingsChanged++data SettingsWritableChangeEventSignalInfo+instance SignalInfo SettingsWritableChangeEventSignalInfo where+    type HaskellCallbackType SettingsWritableChangeEventSignalInfo = SettingsWritableChangeEventCallback+    connectSignal _ = connectSettingsWritableChangeEvent++data SettingsWritableChangedSignalInfo+instance SignalInfo SettingsWritableChangedSignalInfo where+    type HaskellCallbackType SettingsWritableChangedSignalInfo = SettingsWritableChangedCallback+    connectSignal _ = connectSettingsWritableChanged++type instance SignalList Settings = SettingsSignalList+type SettingsSignalList = ('[ '("change-event", SettingsChangeEventSignalInfo), '("changed", SettingsChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("writable-change-event", SettingsWritableChangeEventSignalInfo), '("writable-changed", SettingsWritableChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Settings::new+-- method type : Constructor+-- Args : [Arg {argName = "schema_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "schema_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Settings"+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_new" g_settings_new :: +    CString ->                              -- schema_id : TBasicType TUTF8+    IO (Ptr Settings)+++settingsNew ::+    (MonadIO m) =>+    T.Text ->                               -- schema_id+    m Settings+settingsNew schema_id = liftIO $ do+    schema_id' <- textToCString schema_id+    result <- g_settings_new schema_id'+    checkUnexpectedReturnNULL "g_settings_new" result+    result' <- (wrapObject Settings) result+    freeMem schema_id'+    return result'++-- method Settings::new_full+-- method type : Constructor+-- Args : [Arg {argName = "schema", argType = TInterface "Gio" "SettingsSchema", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "backend", argType = TInterface "Gio" "SettingsBackend", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "schema", argType = TInterface "Gio" "SettingsSchema", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "backend", argType = TInterface "Gio" "SettingsBackend", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Settings"+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_new_full" g_settings_new_full :: +    Ptr SettingsSchema ->                   -- schema : TInterface "Gio" "SettingsSchema"+    Ptr SettingsBackend ->                  -- backend : TInterface "Gio" "SettingsBackend"+    CString ->                              -- path : TBasicType TUTF8+    IO (Ptr Settings)+++settingsNewFull ::+    (MonadIO m) =>+    SettingsSchema ->                       -- schema+    Maybe (SettingsBackend) ->              -- backend+    Maybe (T.Text) ->                       -- path+    m Settings+settingsNewFull schema backend path = liftIO $ do+    let schema' = unsafeManagedPtrGetPtr schema+    maybeBackend <- case backend of+        Nothing -> return nullPtr+        Just jBackend -> do+            let jBackend' = unsafeManagedPtrGetPtr jBackend+            return jBackend'+    maybePath <- case path of+        Nothing -> return nullPtr+        Just jPath -> do+            jPath' <- textToCString jPath+            return jPath'+    result <- g_settings_new_full schema' maybeBackend maybePath+    checkUnexpectedReturnNULL "g_settings_new_full" result+    result' <- (wrapObject Settings) result+    touchManagedPtr schema+    whenJust backend touchManagedPtr+    freeMem maybePath+    return result'++-- method Settings::new_with_backend+-- method type : Constructor+-- Args : [Arg {argName = "schema_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "backend", argType = TInterface "Gio" "SettingsBackend", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "schema_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "backend", argType = TInterface "Gio" "SettingsBackend", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Settings"+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_new_with_backend" g_settings_new_with_backend :: +    CString ->                              -- schema_id : TBasicType TUTF8+    Ptr SettingsBackend ->                  -- backend : TInterface "Gio" "SettingsBackend"+    IO (Ptr Settings)+++settingsNewWithBackend ::+    (MonadIO m) =>+    T.Text ->                               -- schema_id+    SettingsBackend ->                      -- backend+    m Settings+settingsNewWithBackend schema_id backend = liftIO $ do+    schema_id' <- textToCString schema_id+    let backend' = unsafeManagedPtrGetPtr backend+    result <- g_settings_new_with_backend schema_id' backend'+    checkUnexpectedReturnNULL "g_settings_new_with_backend" result+    result' <- (wrapObject Settings) result+    touchManagedPtr backend+    freeMem schema_id'+    return result'++-- method Settings::new_with_backend_and_path+-- method type : Constructor+-- Args : [Arg {argName = "schema_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "backend", argType = TInterface "Gio" "SettingsBackend", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "schema_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "backend", argType = TInterface "Gio" "SettingsBackend", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Settings"+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_new_with_backend_and_path" g_settings_new_with_backend_and_path :: +    CString ->                              -- schema_id : TBasicType TUTF8+    Ptr SettingsBackend ->                  -- backend : TInterface "Gio" "SettingsBackend"+    CString ->                              -- path : TBasicType TUTF8+    IO (Ptr Settings)+++settingsNewWithBackendAndPath ::+    (MonadIO m) =>+    T.Text ->                               -- schema_id+    SettingsBackend ->                      -- backend+    T.Text ->                               -- path+    m Settings+settingsNewWithBackendAndPath schema_id backend path = liftIO $ do+    schema_id' <- textToCString schema_id+    let backend' = unsafeManagedPtrGetPtr backend+    path' <- textToCString path+    result <- g_settings_new_with_backend_and_path schema_id' backend' path'+    checkUnexpectedReturnNULL "g_settings_new_with_backend_and_path" result+    result' <- (wrapObject Settings) result+    touchManagedPtr backend+    freeMem schema_id'+    freeMem path'+    return result'++-- method Settings::new_with_path+-- method type : Constructor+-- Args : [Arg {argName = "schema_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "schema_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Settings"+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_new_with_path" g_settings_new_with_path :: +    CString ->                              -- schema_id : TBasicType TUTF8+    CString ->                              -- path : TBasicType TUTF8+    IO (Ptr Settings)+++settingsNewWithPath ::+    (MonadIO m) =>+    T.Text ->                               -- schema_id+    T.Text ->                               -- path+    m Settings+settingsNewWithPath schema_id path = liftIO $ do+    schema_id' <- textToCString schema_id+    path' <- textToCString path+    result <- g_settings_new_with_path schema_id' path'+    checkUnexpectedReturnNULL "g_settings_new_with_path" result+    result' <- (wrapObject Settings) result+    freeMem schema_id'+    freeMem path'+    return result'++-- method Settings::apply+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_apply" g_settings_apply :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    IO ()+++settingsApply ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- _obj+    m ()+settingsApply _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_settings_apply _obj'+    touchManagedPtr _obj+    return ()++-- method Settings::bind+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "property", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "SettingsBindFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "property", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "SettingsBindFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_bind" g_settings_bind :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    CString ->                              -- key : TBasicType TUTF8+    Ptr GObject.Object ->                   -- object : TInterface "GObject" "Object"+    CString ->                              -- property : TBasicType TUTF8+    CUInt ->                                -- flags : TInterface "Gio" "SettingsBindFlags"+    IO ()+++settingsBind ::+    (MonadIO m, SettingsK a, GObject.ObjectK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    b ->                                    -- object+    T.Text ->                               -- property+    [SettingsBindFlags] ->                  -- flags+    m ()+settingsBind _obj key object property flags = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    let object' = unsafeManagedPtrCastPtr object+    property' <- textToCString property+    let flags' = gflagsToWord flags+    g_settings_bind _obj' key' object' property' flags'+    touchManagedPtr _obj+    touchManagedPtr object+    freeMem key'+    freeMem property'+    return ()++-- method Settings::bind_writable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "property", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "inverted", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "property", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "inverted", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_bind_writable" g_settings_bind_writable :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    CString ->                              -- key : TBasicType TUTF8+    Ptr GObject.Object ->                   -- object : TInterface "GObject" "Object"+    CString ->                              -- property : TBasicType TUTF8+    CInt ->                                 -- inverted : TBasicType TBoolean+    IO ()+++settingsBindWritable ::+    (MonadIO m, SettingsK a, GObject.ObjectK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    b ->                                    -- object+    T.Text ->                               -- property+    Bool ->                                 -- inverted+    m ()+settingsBindWritable _obj key object property inverted = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    let object' = unsafeManagedPtrCastPtr object+    property' <- textToCString property+    let inverted' = (fromIntegral . fromEnum) inverted+    g_settings_bind_writable _obj' key' object' property' inverted'+    touchManagedPtr _obj+    touchManagedPtr object+    freeMem key'+    freeMem property'+    return ()++-- method Settings::create_action+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Action"+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_create_action" g_settings_create_action :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    CString ->                              -- key : TBasicType TUTF8+    IO (Ptr Action)+++settingsCreateAction ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    m Action+settingsCreateAction _obj key = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    result <- g_settings_create_action _obj' key'+    checkUnexpectedReturnNULL "g_settings_create_action" result+    result' <- (wrapObject Action) result+    touchManagedPtr _obj+    freeMem key'+    return result'++-- method Settings::delay+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_delay" g_settings_delay :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    IO ()+++settingsDelay ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- _obj+    m ()+settingsDelay _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_settings_delay _obj'+    touchManagedPtr _obj+    return ()++-- method Settings::get_boolean+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_get_boolean" g_settings_get_boolean :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    CString ->                              -- key : TBasicType TUTF8+    IO CInt+++settingsGetBoolean ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    m Bool+settingsGetBoolean _obj key = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    result <- g_settings_get_boolean _obj' key'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem key'+    return result'++-- method Settings::get_child+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Settings"+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_get_child" g_settings_get_child :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr Settings)+++settingsGetChild ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- name+    m Settings+settingsGetChild _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name' <- textToCString name+    result <- g_settings_get_child _obj' name'+    checkUnexpectedReturnNULL "g_settings_get_child" result+    result' <- (wrapObject Settings) result+    touchManagedPtr _obj+    freeMem name'+    return result'++-- method Settings::get_default_value+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TVariant+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_get_default_value" g_settings_get_default_value :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    CString ->                              -- key : TBasicType TUTF8+    IO (Ptr GVariant)+++settingsGetDefaultValue ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    m GVariant+settingsGetDefaultValue _obj key = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    result <- g_settings_get_default_value _obj' key'+    checkUnexpectedReturnNULL "g_settings_get_default_value" result+    result' <- wrapGVariantPtr result+    touchManagedPtr _obj+    freeMem key'+    return result'++-- method Settings::get_double+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_get_double" g_settings_get_double :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    CString ->                              -- key : TBasicType TUTF8+    IO CDouble+++settingsGetDouble ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    m Double+settingsGetDouble _obj key = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    result <- g_settings_get_double _obj' key'+    let result' = realToFrac result+    touchManagedPtr _obj+    freeMem key'+    return result'++-- method Settings::get_enum+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_get_enum" g_settings_get_enum :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    CString ->                              -- key : TBasicType TUTF8+    IO Int32+++settingsGetEnum ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    m Int32+settingsGetEnum _obj key = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    result <- g_settings_get_enum _obj' key'+    touchManagedPtr _obj+    freeMem key'+    return result++-- method Settings::get_flags+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_get_flags" g_settings_get_flags :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    CString ->                              -- key : TBasicType TUTF8+    IO Word32+++settingsGetFlags ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    m Word32+settingsGetFlags _obj key = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    result <- g_settings_get_flags _obj' key'+    touchManagedPtr _obj+    freeMem key'+    return result++-- method Settings::get_has_unapplied+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_get_has_unapplied" g_settings_get_has_unapplied :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    IO CInt+++settingsGetHasUnapplied ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- _obj+    m Bool+settingsGetHasUnapplied _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_settings_get_has_unapplied _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Settings::get_int+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_get_int" g_settings_get_int :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    CString ->                              -- key : TBasicType TUTF8+    IO Int32+++settingsGetInt ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    m Int32+settingsGetInt _obj key = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    result <- g_settings_get_int _obj' key'+    touchManagedPtr _obj+    freeMem key'+    return result++-- method Settings::get_mapped+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mapping", argType = TInterface "Gio" "SettingsGetMapping", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 3, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mapping", argType = TInterface "Gio" "SettingsGetMapping", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 3, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_get_mapped" g_settings_get_mapped :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    CString ->                              -- key : TBasicType TUTF8+    FunPtr SettingsGetMappingC ->           -- mapping : TInterface "Gio" "SettingsGetMapping"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++settingsGetMapped ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    SettingsGetMapping ->                   -- mapping+    m ()+settingsGetMapped _obj key mapping = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    mapping' <- mkSettingsGetMapping (settingsGetMappingWrapper Nothing mapping)+    let user_data = nullPtr+    g_settings_get_mapped _obj' key' mapping' user_data+    safeFreeFunPtr $ castFunPtrToPtr mapping'+    touchManagedPtr _obj+    freeMem key'+    return ()++-- method Settings::get_range+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TVariant+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_get_range" g_settings_get_range :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    CString ->                              -- key : TBasicType TUTF8+    IO (Ptr GVariant)++{-# DEPRECATED settingsGetRange ["(Since version 2.40)","Use g_settings_schema_key_get_range() instead."]#-}+settingsGetRange ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    m GVariant+settingsGetRange _obj key = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    result <- g_settings_get_range _obj' key'+    checkUnexpectedReturnNULL "g_settings_get_range" result+    result' <- wrapGVariantPtr result+    touchManagedPtr _obj+    freeMem key'+    return result'++-- method Settings::get_string+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_get_string" g_settings_get_string :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    CString ->                              -- key : TBasicType TUTF8+    IO CString+++settingsGetString ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    m T.Text+settingsGetString _obj key = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    result <- g_settings_get_string _obj' key'+    checkUnexpectedReturnNULL "g_settings_get_string" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    freeMem key'+    return result'++-- method Settings::get_strv+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_get_strv" g_settings_get_strv :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    CString ->                              -- key : TBasicType TUTF8+    IO (Ptr CString)+++settingsGetStrv ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    m [T.Text]+settingsGetStrv _obj key = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    result <- g_settings_get_strv _obj' key'+    checkUnexpectedReturnNULL "g_settings_get_strv" result+    result' <- unpackZeroTerminatedUTF8CArray result+    mapZeroTerminatedCArray freeMem result+    freeMem result+    touchManagedPtr _obj+    freeMem key'+    return result'++-- method Settings::get_uint+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_get_uint" g_settings_get_uint :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    CString ->                              -- key : TBasicType TUTF8+    IO Word32+++settingsGetUint ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    m Word32+settingsGetUint _obj key = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    result <- g_settings_get_uint _obj' key'+    touchManagedPtr _obj+    freeMem key'+    return result++-- method Settings::get_user_value+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TVariant+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_get_user_value" g_settings_get_user_value :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    CString ->                              -- key : TBasicType TUTF8+    IO (Ptr GVariant)+++settingsGetUserValue ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    m GVariant+settingsGetUserValue _obj key = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    result <- g_settings_get_user_value _obj' key'+    checkUnexpectedReturnNULL "g_settings_get_user_value" result+    result' <- wrapGVariantPtr result+    touchManagedPtr _obj+    freeMem key'+    return result'++-- method Settings::get_value+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TVariant+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_get_value" g_settings_get_value :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    CString ->                              -- key : TBasicType TUTF8+    IO (Ptr GVariant)+++settingsGetValue ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    m GVariant+settingsGetValue _obj key = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    result <- g_settings_get_value _obj' key'+    checkUnexpectedReturnNULL "g_settings_get_value" result+    result' <- wrapGVariantPtr result+    touchManagedPtr _obj+    freeMem key'+    return result'++-- method Settings::is_writable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_is_writable" g_settings_is_writable :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    CString ->                              -- name : TBasicType TUTF8+    IO CInt+++settingsIsWritable ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- name+    m Bool+settingsIsWritable _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name' <- textToCString name+    result <- g_settings_is_writable _obj' name'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem name'+    return result'++-- method Settings::list_children+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_list_children" g_settings_list_children :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    IO (Ptr CString)+++settingsListChildren ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- _obj+    m [T.Text]+settingsListChildren _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_settings_list_children _obj'+    checkUnexpectedReturnNULL "g_settings_list_children" result+    result' <- unpackZeroTerminatedUTF8CArray result+    mapZeroTerminatedCArray freeMem result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method Settings::list_keys+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_list_keys" g_settings_list_keys :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    IO (Ptr CString)+++settingsListKeys ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- _obj+    m [T.Text]+settingsListKeys _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_settings_list_keys _obj'+    checkUnexpectedReturnNULL "g_settings_list_keys" result+    result' <- unpackZeroTerminatedUTF8CArray result+    mapZeroTerminatedCArray freeMem result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method Settings::range_check+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TVariant, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TVariant, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_range_check" g_settings_range_check :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    CString ->                              -- key : TBasicType TUTF8+    Ptr GVariant ->                         -- value : TVariant+    IO CInt++{-# DEPRECATED settingsRangeCheck ["(Since version 2.40)","Use g_settings_schema_key_range_check() instead."]#-}+settingsRangeCheck ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    GVariant ->                             -- value+    m Bool+settingsRangeCheck _obj key value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    let value' = unsafeManagedPtrGetPtr value+    result <- g_settings_range_check _obj' key' value'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem key'+    return result'++-- method Settings::reset+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_reset" g_settings_reset :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    CString ->                              -- key : TBasicType TUTF8+    IO ()+++settingsReset ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    m ()+settingsReset _obj key = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    g_settings_reset _obj' key'+    touchManagedPtr _obj+    freeMem key'+    return ()++-- method Settings::revert+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_revert" g_settings_revert :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    IO ()+++settingsRevert ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- _obj+    m ()+settingsRevert _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_settings_revert _obj'+    touchManagedPtr _obj+    return ()++-- method Settings::set_boolean+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_set_boolean" g_settings_set_boolean :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    CString ->                              -- key : TBasicType TUTF8+    CInt ->                                 -- value : TBasicType TBoolean+    IO CInt+++settingsSetBoolean ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    Bool ->                                 -- value+    m Bool+settingsSetBoolean _obj key value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    let value' = (fromIntegral . fromEnum) value+    result <- g_settings_set_boolean _obj' key' value'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem key'+    return result'++-- method Settings::set_double+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_set_double" g_settings_set_double :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    CString ->                              -- key : TBasicType TUTF8+    CDouble ->                              -- value : TBasicType TDouble+    IO CInt+++settingsSetDouble ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    Double ->                               -- value+    m Bool+settingsSetDouble _obj key value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    let value' = realToFrac value+    result <- g_settings_set_double _obj' key' value'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem key'+    return result'++-- method Settings::set_enum+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_set_enum" g_settings_set_enum :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    CString ->                              -- key : TBasicType TUTF8+    Int32 ->                                -- value : TBasicType TInt32+    IO CInt+++settingsSetEnum ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    Int32 ->                                -- value+    m Bool+settingsSetEnum _obj key value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    result <- g_settings_set_enum _obj' key' value+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem key'+    return result'++-- method Settings::set_flags+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_set_flags" g_settings_set_flags :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    CString ->                              -- key : TBasicType TUTF8+    Word32 ->                               -- value : TBasicType TUInt32+    IO CInt+++settingsSetFlags ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    Word32 ->                               -- value+    m Bool+settingsSetFlags _obj key value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    result <- g_settings_set_flags _obj' key' value+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem key'+    return result'++-- method Settings::set_int+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_set_int" g_settings_set_int :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    CString ->                              -- key : TBasicType TUTF8+    Int32 ->                                -- value : TBasicType TInt32+    IO CInt+++settingsSetInt ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    Int32 ->                                -- value+    m Bool+settingsSetInt _obj key value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    result <- g_settings_set_int _obj' key' value+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem key'+    return result'++-- method Settings::set_string+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_set_string" g_settings_set_string :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    CString ->                              -- key : TBasicType TUTF8+    CString ->                              -- value : TBasicType TUTF8+    IO CInt+++settingsSetString ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    T.Text ->                               -- value+    m Bool+settingsSetString _obj key value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    value' <- textToCString value+    result <- g_settings_set_string _obj' key' value'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem key'+    freeMem value'+    return result'++-- method Settings::set_strv+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_set_strv" g_settings_set_strv :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    CString ->                              -- key : TBasicType TUTF8+    Ptr CString ->                          -- value : TCArray True (-1) (-1) (TBasicType TUTF8)+    IO CInt+++settingsSetStrv ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    Maybe ([T.Text]) ->                     -- value+    m Bool+settingsSetStrv _obj key value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    maybeValue <- case value of+        Nothing -> return nullPtr+        Just jValue -> do+            jValue' <- packZeroTerminatedUTF8CArray jValue+            return jValue'+    result <- g_settings_set_strv _obj' key' maybeValue+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem key'+    mapZeroTerminatedCArray freeMem maybeValue+    freeMem maybeValue+    return result'++-- method Settings::set_uint+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_set_uint" g_settings_set_uint :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    CString ->                              -- key : TBasicType TUTF8+    Word32 ->                               -- value : TBasicType TUInt32+    IO CInt+++settingsSetUint ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    Word32 ->                               -- value+    m Bool+settingsSetUint _obj key value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    result <- g_settings_set_uint _obj' key' value+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem key'+    return result'++-- method Settings::set_value+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TVariant, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TVariant, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_set_value" g_settings_set_value :: +    Ptr Settings ->                         -- _obj : TInterface "Gio" "Settings"+    CString ->                              -- key : TBasicType TUTF8+    Ptr GVariant ->                         -- value : TVariant+    IO CInt+++settingsSetValue ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    GVariant ->                             -- value+    m Bool+settingsSetValue _obj key value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    let value' = unsafeManagedPtrGetPtr value+    result <- g_settings_set_value _obj' key' value'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem key'+    return result'++-- method Settings::list_relocatable_schemas+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_list_relocatable_schemas" g_settings_list_relocatable_schemas :: +    IO (Ptr CString)++{-# DEPRECATED settingsListRelocatableSchemas ["(Since version 2.40)","Use g_settings_schema_source_list_schemas() instead"]#-}+settingsListRelocatableSchemas ::+    (MonadIO m) =>+    m [T.Text]+settingsListRelocatableSchemas  = liftIO $ do+    result <- g_settings_list_relocatable_schemas+    checkUnexpectedReturnNULL "g_settings_list_relocatable_schemas" result+    result' <- unpackZeroTerminatedUTF8CArray result+    return result'++-- method Settings::list_schemas+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_list_schemas" g_settings_list_schemas :: +    IO (Ptr CString)++{-# DEPRECATED settingsListSchemas ["(Since version 2.40)","Use g_settings_schema_source_list_schemas() instead.","If you used g_settings_list_schemas() to check for the presence of","a particular schema, use g_settings_schema_source_lookup() instead","of your whole loop."]#-}+settingsListSchemas ::+    (MonadIO m) =>+    m [T.Text]+settingsListSchemas  = liftIO $ do+    result <- g_settings_list_schemas+    checkUnexpectedReturnNULL "g_settings_list_schemas" result+    result' <- unpackZeroTerminatedUTF8CArray result+    return result'++-- method Settings::sync+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_sync" g_settings_sync :: +    IO ()+++settingsSync ::+    (MonadIO m) =>+    m ()+settingsSync  = liftIO $ do+    g_settings_sync+    return ()++-- method Settings::unbind+-- method type : MemberFunction+-- Args : [Arg {argName = "object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "property", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "property", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_unbind" g_settings_unbind :: +    Ptr GObject.Object ->                   -- object : TInterface "GObject" "Object"+    CString ->                              -- property : TBasicType TUTF8+    IO ()+++settingsUnbind ::+    (MonadIO m, GObject.ObjectK a) =>+    a ->                                    -- object+    T.Text ->                               -- property+    m ()+settingsUnbind object property = liftIO $ do+    let object' = unsafeManagedPtrCastPtr object+    property' <- textToCString property+    g_settings_unbind object' property'+    touchManagedPtr object+    freeMem property'+    return ()++
+ GI/Gio/Objects/Settings.hs-boot view
@@ -0,0 +1,23 @@+module GI.Gio.Objects.Settings where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Settings = Settings (ForeignPtr Settings)+instance GObject Settings where+class GObject o => SettingsK o+instance (GObject o, IsDescendantOf Settings o) => SettingsK o+data SettingsDelayApplyPropertyInfo+data SettingsHasUnappliedPropertyInfo+data SettingsPathPropertyInfo+data SettingsSchemaPropertyInfo+data SettingsSchemaIdPropertyInfo+data SettingsSettingsSchemaPropertyInfo+data SettingsChangeEventSignalInfo+data SettingsChangedSignalInfo+data SettingsWritableChangeEventSignalInfo+data SettingsWritableChangedSignalInfo
+ GI/Gio/Objects/SimpleAction.hs view
@@ -0,0 +1,523 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.SimpleAction+    ( ++-- * Exported types+    SimpleAction(..)                        ,+    SimpleActionK                           ,+    toSimpleAction                          ,+    noSimpleAction                          ,+++ -- * Methods+-- ** simpleActionNew+    simpleActionNew                         ,+++-- ** simpleActionNewStateful+    simpleActionNewStateful                 ,+++-- ** simpleActionSetEnabled+    simpleActionSetEnabled                  ,+++-- ** simpleActionSetState+    simpleActionSetState                    ,+++-- ** simpleActionSetStateHint+    simpleActionSetStateHint                ,+++++ -- * Properties+-- ** Enabled+    SimpleActionEnabledPropertyInfo         ,+    constructSimpleActionEnabled            ,+    getSimpleActionEnabled                  ,+    setSimpleActionEnabled                  ,+++-- ** Name+    SimpleActionNamePropertyInfo            ,+    constructSimpleActionName               ,+    getSimpleActionName                     ,+++-- ** ParameterType+    SimpleActionParameterTypePropertyInfo   ,+    constructSimpleActionParameterType      ,+    getSimpleActionParameterType            ,+++-- ** State+    SimpleActionStatePropertyInfo           ,+    constructSimpleActionState              ,+    getSimpleActionState                    ,+    setSimpleActionState                    ,+++-- ** StateType+    SimpleActionStateTypePropertyInfo       ,+    getSimpleActionStateType                ,+++++ -- * Signals+-- ** Activate+    SimpleActionActivateCallback            ,+    SimpleActionActivateCallbackC           ,+    SimpleActionActivateSignalInfo          ,+    afterSimpleActionActivate               ,+    mkSimpleActionActivateCallback          ,+    noSimpleActionActivateCallback          ,+    onSimpleActionActivate                  ,+    simpleActionActivateCallbackWrapper     ,+    simpleActionActivateClosure             ,+++-- ** ChangeState+    SimpleActionChangeStateCallback         ,+    SimpleActionChangeStateCallbackC        ,+    SimpleActionChangeStateSignalInfo       ,+    afterSimpleActionChangeState            ,+    mkSimpleActionChangeStateCallback       ,+    noSimpleActionChangeStateCallback       ,+    onSimpleActionChangeState               ,+    simpleActionChangeStateCallbackWrapper  ,+    simpleActionChangeStateClosure          ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype SimpleAction = SimpleAction (ForeignPtr SimpleAction)+foreign import ccall "g_simple_action_get_type"+    c_g_simple_action_get_type :: IO GType++type instance ParentTypes SimpleAction = SimpleActionParentTypes+type SimpleActionParentTypes = '[GObject.Object, Action]++instance GObject SimpleAction where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_simple_action_get_type+    ++class GObject o => SimpleActionK o+instance (GObject o, IsDescendantOf SimpleAction o) => SimpleActionK o++toSimpleAction :: SimpleActionK o => o -> IO SimpleAction+toSimpleAction = unsafeCastTo SimpleAction++noSimpleAction :: Maybe SimpleAction+noSimpleAction = Nothing++-- signal SimpleAction::activate+type SimpleActionActivateCallback =+    Maybe GVariant ->+    IO ()++noSimpleActionActivateCallback :: Maybe SimpleActionActivateCallback+noSimpleActionActivateCallback = Nothing++type SimpleActionActivateCallbackC =+    Ptr () ->                               -- object+    Ptr GVariant ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkSimpleActionActivateCallback :: SimpleActionActivateCallbackC -> IO (FunPtr SimpleActionActivateCallbackC)++simpleActionActivateClosure :: SimpleActionActivateCallback -> IO Closure+simpleActionActivateClosure cb = newCClosure =<< mkSimpleActionActivateCallback wrapped+    where wrapped = simpleActionActivateCallbackWrapper cb++simpleActionActivateCallbackWrapper ::+    SimpleActionActivateCallback ->+    Ptr () ->+    Ptr GVariant ->+    Ptr () ->+    IO ()+simpleActionActivateCallbackWrapper _cb _ parameter _ = do+    maybeParameter <-+        if parameter == nullPtr+        then return Nothing+        else do+            parameter' <- newGVariantFromPtr parameter+            return $ Just parameter'+    _cb  maybeParameter++onSimpleActionActivate :: (GObject a, MonadIO m) => a -> SimpleActionActivateCallback -> m SignalHandlerId+onSimpleActionActivate obj cb = liftIO $ connectSimpleActionActivate obj cb SignalConnectBefore+afterSimpleActionActivate :: (GObject a, MonadIO m) => a -> SimpleActionActivateCallback -> m SignalHandlerId+afterSimpleActionActivate obj cb = connectSimpleActionActivate obj cb SignalConnectAfter++connectSimpleActionActivate :: (GObject a, MonadIO m) =>+                               a -> SimpleActionActivateCallback -> SignalConnectMode -> m SignalHandlerId+connectSimpleActionActivate obj cb after = liftIO $ do+    cb' <- mkSimpleActionActivateCallback (simpleActionActivateCallbackWrapper cb)+    connectSignalFunPtr obj "activate" cb' after++-- signal SimpleAction::change-state+type SimpleActionChangeStateCallback =+    Maybe GVariant ->+    IO ()++noSimpleActionChangeStateCallback :: Maybe SimpleActionChangeStateCallback+noSimpleActionChangeStateCallback = Nothing++type SimpleActionChangeStateCallbackC =+    Ptr () ->                               -- object+    Ptr GVariant ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkSimpleActionChangeStateCallback :: SimpleActionChangeStateCallbackC -> IO (FunPtr SimpleActionChangeStateCallbackC)++simpleActionChangeStateClosure :: SimpleActionChangeStateCallback -> IO Closure+simpleActionChangeStateClosure cb = newCClosure =<< mkSimpleActionChangeStateCallback wrapped+    where wrapped = simpleActionChangeStateCallbackWrapper cb++simpleActionChangeStateCallbackWrapper ::+    SimpleActionChangeStateCallback ->+    Ptr () ->+    Ptr GVariant ->+    Ptr () ->+    IO ()+simpleActionChangeStateCallbackWrapper _cb _ value _ = do+    maybeValue <-+        if value == nullPtr+        then return Nothing+        else do+            value' <- newGVariantFromPtr value+            return $ Just value'+    _cb  maybeValue++onSimpleActionChangeState :: (GObject a, MonadIO m) => a -> SimpleActionChangeStateCallback -> m SignalHandlerId+onSimpleActionChangeState obj cb = liftIO $ connectSimpleActionChangeState obj cb SignalConnectBefore+afterSimpleActionChangeState :: (GObject a, MonadIO m) => a -> SimpleActionChangeStateCallback -> m SignalHandlerId+afterSimpleActionChangeState obj cb = connectSimpleActionChangeState obj cb SignalConnectAfter++connectSimpleActionChangeState :: (GObject a, MonadIO m) =>+                                  a -> SimpleActionChangeStateCallback -> SignalConnectMode -> m SignalHandlerId+connectSimpleActionChangeState obj cb after = liftIO $ do+    cb' <- mkSimpleActionChangeStateCallback (simpleActionChangeStateCallbackWrapper cb)+    connectSignalFunPtr obj "change-state" cb' after++--- XXX Duplicated object with different types:+  --- Name {namespace = "Gio", name = "SimpleAction"} -> Property {propName = "enabled", propType = TBasicType TBoolean, propFlags = [PropertyReadable,PropertyWritable], propTransfer = TransferNothing, propDeprecated = Nothing}+  --- Name {namespace = "Gio", name = "Action"} -> Property {propName = "enabled", propType = TBasicType TBoolean, propFlags = [PropertyReadable], propTransfer = TransferNothing, propDeprecated = Nothing}+--- XXX Duplicated object with different types:+  --- Name {namespace = "Gio", name = "SimpleAction"} -> Property {propName = "name", propType = TBasicType TUTF8, propFlags = [PropertyReadable,PropertyWritable,PropertyConstructOnly], propTransfer = TransferNothing, propDeprecated = Nothing}+  --- Name {namespace = "Gio", name = "Action"} -> Property {propName = "name", propType = TBasicType TUTF8, propFlags = [PropertyReadable], propTransfer = TransferNothing, propDeprecated = Nothing}+--- XXX Duplicated object with different types:+  --- Name {namespace = "Gio", name = "SimpleAction"} -> Property {propName = "parameter-type", propType = TInterface "GLib" "VariantType", propFlags = [PropertyReadable,PropertyWritable,PropertyConstructOnly], propTransfer = TransferNothing, propDeprecated = Nothing}+  --- Name {namespace = "Gio", name = "Action"} -> Property {propName = "parameter-type", propType = TInterface "GLib" "VariantType", propFlags = [PropertyReadable], propTransfer = TransferNothing, propDeprecated = Nothing}+--- XXX Duplicated object with different types:+  --- Name {namespace = "Gio", name = "SimpleAction"} -> Property {propName = "state", propType = TVariant, propFlags = [PropertyReadable,PropertyWritable,PropertyConstruct], propTransfer = TransferNothing, propDeprecated = Nothing}+  --- Name {namespace = "Gio", name = "Action"} -> Property {propName = "state", propType = TVariant, propFlags = [PropertyReadable], propTransfer = TransferNothing, propDeprecated = Nothing}+-- VVV Prop "enabled"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getSimpleActionEnabled :: (MonadIO m, SimpleActionK o) => o -> m Bool+getSimpleActionEnabled obj = liftIO $ getObjectPropertyBool obj "enabled"++setSimpleActionEnabled :: (MonadIO m, SimpleActionK o) => o -> Bool -> m ()+setSimpleActionEnabled obj val = liftIO $ setObjectPropertyBool obj "enabled" val++constructSimpleActionEnabled :: Bool -> IO ([Char], GValue)+constructSimpleActionEnabled val = constructObjectPropertyBool "enabled" val++data SimpleActionEnabledPropertyInfo+instance AttrInfo SimpleActionEnabledPropertyInfo where+    type AttrAllowedOps SimpleActionEnabledPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SimpleActionEnabledPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint SimpleActionEnabledPropertyInfo = SimpleActionK+    type AttrGetType SimpleActionEnabledPropertyInfo = Bool+    type AttrLabel SimpleActionEnabledPropertyInfo = "SimpleAction::enabled"+    attrGet _ = getSimpleActionEnabled+    attrSet _ = setSimpleActionEnabled+    attrConstruct _ = constructSimpleActionEnabled++-- VVV Prop "name"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getSimpleActionName :: (MonadIO m, SimpleActionK o) => o -> m T.Text+getSimpleActionName obj = liftIO $ getObjectPropertyString obj "name"++constructSimpleActionName :: T.Text -> IO ([Char], GValue)+constructSimpleActionName val = constructObjectPropertyString "name" val++data SimpleActionNamePropertyInfo+instance AttrInfo SimpleActionNamePropertyInfo where+    type AttrAllowedOps SimpleActionNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SimpleActionNamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint SimpleActionNamePropertyInfo = SimpleActionK+    type AttrGetType SimpleActionNamePropertyInfo = T.Text+    type AttrLabel SimpleActionNamePropertyInfo = "SimpleAction::name"+    attrGet _ = getSimpleActionName+    attrSet _ = undefined+    attrConstruct _ = constructSimpleActionName++-- VVV Prop "parameter-type"+   -- Type: TInterface "GLib" "VariantType"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getSimpleActionParameterType :: (MonadIO m, SimpleActionK o) => o -> m GLib.VariantType+getSimpleActionParameterType obj = liftIO $ getObjectPropertyBoxed obj "parameter-type" GLib.VariantType++constructSimpleActionParameterType :: GLib.VariantType -> IO ([Char], GValue)+constructSimpleActionParameterType val = constructObjectPropertyBoxed "parameter-type" val++data SimpleActionParameterTypePropertyInfo+instance AttrInfo SimpleActionParameterTypePropertyInfo where+    type AttrAllowedOps SimpleActionParameterTypePropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SimpleActionParameterTypePropertyInfo = (~) GLib.VariantType+    type AttrBaseTypeConstraint SimpleActionParameterTypePropertyInfo = SimpleActionK+    type AttrGetType SimpleActionParameterTypePropertyInfo = GLib.VariantType+    type AttrLabel SimpleActionParameterTypePropertyInfo = "SimpleAction::parameter-type"+    attrGet _ = getSimpleActionParameterType+    attrSet _ = undefined+    attrConstruct _ = constructSimpleActionParameterType++-- VVV Prop "state"+   -- Type: TVariant+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getSimpleActionState :: (MonadIO m, SimpleActionK o) => o -> m GVariant+getSimpleActionState obj = liftIO $ getObjectPropertyVariant obj "state"++setSimpleActionState :: (MonadIO m, SimpleActionK o) => o -> GVariant -> m ()+setSimpleActionState obj val = liftIO $ setObjectPropertyVariant obj "state" val++constructSimpleActionState :: GVariant -> IO ([Char], GValue)+constructSimpleActionState val = constructObjectPropertyVariant "state" val++data SimpleActionStatePropertyInfo+instance AttrInfo SimpleActionStatePropertyInfo where+    type AttrAllowedOps SimpleActionStatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SimpleActionStatePropertyInfo = (~) GVariant+    type AttrBaseTypeConstraint SimpleActionStatePropertyInfo = SimpleActionK+    type AttrGetType SimpleActionStatePropertyInfo = GVariant+    type AttrLabel SimpleActionStatePropertyInfo = "SimpleAction::state"+    attrGet _ = getSimpleActionState+    attrSet _ = setSimpleActionState+    attrConstruct _ = constructSimpleActionState++-- VVV Prop "state-type"+   -- Type: TInterface "GLib" "VariantType"+   -- Flags: [PropertyReadable]++getSimpleActionStateType :: (MonadIO m, SimpleActionK o) => o -> m GLib.VariantType+getSimpleActionStateType obj = liftIO $ getObjectPropertyBoxed obj "state-type" GLib.VariantType++data SimpleActionStateTypePropertyInfo+instance AttrInfo SimpleActionStateTypePropertyInfo where+    type AttrAllowedOps SimpleActionStateTypePropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint SimpleActionStateTypePropertyInfo = (~) ()+    type AttrBaseTypeConstraint SimpleActionStateTypePropertyInfo = SimpleActionK+    type AttrGetType SimpleActionStateTypePropertyInfo = GLib.VariantType+    type AttrLabel SimpleActionStateTypePropertyInfo = "SimpleAction::state-type"+    attrGet _ = getSimpleActionStateType+    attrSet _ = undefined+    attrConstruct _ = undefined++type instance AttributeList SimpleAction = SimpleActionAttributeList+type SimpleActionAttributeList = ('[ '("state-type", SimpleActionStateTypePropertyInfo)] :: [(Symbol, *)])++data SimpleActionActivateSignalInfo+instance SignalInfo SimpleActionActivateSignalInfo where+    type HaskellCallbackType SimpleActionActivateSignalInfo = SimpleActionActivateCallback+    connectSignal _ = connectSimpleActionActivate++data SimpleActionChangeStateSignalInfo+instance SignalInfo SimpleActionChangeStateSignalInfo where+    type HaskellCallbackType SimpleActionChangeStateSignalInfo = SimpleActionChangeStateCallback+    connectSignal _ = connectSimpleActionChangeState++type instance SignalList SimpleAction = SimpleActionSignalList+type SimpleActionSignalList = ('[ '("activate", SimpleActionActivateSignalInfo), '("change-state", SimpleActionChangeStateSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method SimpleAction::new+-- method type : Constructor+-- Args : [Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameter_type", argType = TInterface "GLib" "VariantType", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameter_type", argType = TInterface "GLib" "VariantType", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SimpleAction"+-- throws : False+-- Skip return : False++foreign import ccall "g_simple_action_new" g_simple_action_new :: +    CString ->                              -- name : TBasicType TUTF8+    Ptr GLib.VariantType ->                 -- parameter_type : TInterface "GLib" "VariantType"+    IO (Ptr SimpleAction)+++simpleActionNew ::+    (MonadIO m) =>+    T.Text ->                               -- name+    Maybe (GLib.VariantType) ->             -- parameter_type+    m SimpleAction+simpleActionNew name parameter_type = liftIO $ do+    name' <- textToCString name+    maybeParameter_type <- case parameter_type of+        Nothing -> return nullPtr+        Just jParameter_type -> do+            let jParameter_type' = unsafeManagedPtrGetPtr jParameter_type+            return jParameter_type'+    result <- g_simple_action_new name' maybeParameter_type+    checkUnexpectedReturnNULL "g_simple_action_new" result+    result' <- (wrapObject SimpleAction) result+    whenJust parameter_type touchManagedPtr+    freeMem name'+    return result'++-- method SimpleAction::new_stateful+-- method type : Constructor+-- Args : [Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameter_type", argType = TInterface "GLib" "VariantType", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state", argType = TVariant, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parameter_type", argType = TInterface "GLib" "VariantType", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state", argType = TVariant, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SimpleAction"+-- throws : False+-- Skip return : False++foreign import ccall "g_simple_action_new_stateful" g_simple_action_new_stateful :: +    CString ->                              -- name : TBasicType TUTF8+    Ptr GLib.VariantType ->                 -- parameter_type : TInterface "GLib" "VariantType"+    Ptr GVariant ->                         -- state : TVariant+    IO (Ptr SimpleAction)+++simpleActionNewStateful ::+    (MonadIO m) =>+    T.Text ->                               -- name+    Maybe (GLib.VariantType) ->             -- parameter_type+    GVariant ->                             -- state+    m SimpleAction+simpleActionNewStateful name parameter_type state = liftIO $ do+    name' <- textToCString name+    maybeParameter_type <- case parameter_type of+        Nothing -> return nullPtr+        Just jParameter_type -> do+            let jParameter_type' = unsafeManagedPtrGetPtr jParameter_type+            return jParameter_type'+    let state' = unsafeManagedPtrGetPtr state+    result <- g_simple_action_new_stateful name' maybeParameter_type state'+    checkUnexpectedReturnNULL "g_simple_action_new_stateful" result+    result' <- (wrapObject SimpleAction) result+    whenJust parameter_type touchManagedPtr+    freeMem name'+    return result'++-- method SimpleAction::set_enabled+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleAction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleAction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_simple_action_set_enabled" g_simple_action_set_enabled :: +    Ptr SimpleAction ->                     -- _obj : TInterface "Gio" "SimpleAction"+    CInt ->                                 -- enabled : TBasicType TBoolean+    IO ()+++simpleActionSetEnabled ::+    (MonadIO m, SimpleActionK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- enabled+    m ()+simpleActionSetEnabled _obj enabled = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let enabled' = (fromIntegral . fromEnum) enabled+    g_simple_action_set_enabled _obj' enabled'+    touchManagedPtr _obj+    return ()++-- method SimpleAction::set_state+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleAction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TVariant, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleAction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TVariant, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_simple_action_set_state" g_simple_action_set_state :: +    Ptr SimpleAction ->                     -- _obj : TInterface "Gio" "SimpleAction"+    Ptr GVariant ->                         -- value : TVariant+    IO ()+++simpleActionSetState ::+    (MonadIO m, SimpleActionK a) =>+    a ->                                    -- _obj+    GVariant ->                             -- value+    m ()+simpleActionSetState _obj value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let value' = unsafeManagedPtrGetPtr value+    g_simple_action_set_state _obj' value'+    touchManagedPtr _obj+    return ()++-- method SimpleAction::set_state_hint+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleAction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_hint", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleAction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_hint", argType = TVariant, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_simple_action_set_state_hint" g_simple_action_set_state_hint :: +    Ptr SimpleAction ->                     -- _obj : TInterface "Gio" "SimpleAction"+    Ptr GVariant ->                         -- state_hint : TVariant+    IO ()+++simpleActionSetStateHint ::+    (MonadIO m, SimpleActionK a) =>+    a ->                                    -- _obj+    Maybe (GVariant) ->                     -- state_hint+    m ()+simpleActionSetStateHint _obj state_hint = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeState_hint <- case state_hint of+        Nothing -> return nullPtr+        Just jState_hint -> do+            let jState_hint' = unsafeManagedPtrGetPtr jState_hint+            return jState_hint'+    g_simple_action_set_state_hint _obj' maybeState_hint+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Objects/SimpleAction.hs-boot view
@@ -0,0 +1,20 @@+module GI.Gio.Objects.SimpleAction where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype SimpleAction = SimpleAction (ForeignPtr SimpleAction)+instance GObject SimpleAction where+class GObject o => SimpleActionK o+instance (GObject o, IsDescendantOf SimpleAction o) => SimpleActionK o+data SimpleActionEnabledPropertyInfo+data SimpleActionNamePropertyInfo+data SimpleActionParameterTypePropertyInfo+data SimpleActionStatePropertyInfo+data SimpleActionStateTypePropertyInfo+data SimpleActionActivateSignalInfo+data SimpleActionChangeStateSignalInfo
+ GI/Gio/Objects/SimpleActionGroup.hs view
@@ -0,0 +1,223 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.SimpleActionGroup+    ( ++-- * Exported types+    SimpleActionGroup(..)                   ,+    SimpleActionGroupK                      ,+    toSimpleActionGroup                     ,+    noSimpleActionGroup                     ,+++ -- * Methods+-- ** simpleActionGroupAddEntries+    simpleActionGroupAddEntries             ,+++-- ** simpleActionGroupInsert+    simpleActionGroupInsert                 ,+++-- ** simpleActionGroupLookup+    simpleActionGroupLookup                 ,+++-- ** simpleActionGroupNew+    simpleActionGroupNew                    ,+++-- ** simpleActionGroupRemove+    simpleActionGroupRemove                 ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype SimpleActionGroup = SimpleActionGroup (ForeignPtr SimpleActionGroup)+foreign import ccall "g_simple_action_group_get_type"+    c_g_simple_action_group_get_type :: IO GType++type instance ParentTypes SimpleActionGroup = SimpleActionGroupParentTypes+type SimpleActionGroupParentTypes = '[GObject.Object, ActionGroup, ActionMap]++instance GObject SimpleActionGroup where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_simple_action_group_get_type+    ++class GObject o => SimpleActionGroupK o+instance (GObject o, IsDescendantOf SimpleActionGroup o) => SimpleActionGroupK o++toSimpleActionGroup :: SimpleActionGroupK o => o -> IO SimpleActionGroup+toSimpleActionGroup = unsafeCastTo SimpleActionGroup++noSimpleActionGroup :: Maybe SimpleActionGroup+noSimpleActionGroup = Nothing++type instance AttributeList SimpleActionGroup = SimpleActionGroupAttributeList+type SimpleActionGroupAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList SimpleActionGroup = SimpleActionGroupSignalList+type SimpleActionGroupSignalList = ('[ '("action-added", ActionGroupActionAddedSignalInfo), '("action-enabled-changed", ActionGroupActionEnabledChangedSignalInfo), '("action-removed", ActionGroupActionRemovedSignalInfo), '("action-state-changed", ActionGroupActionStateChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method SimpleActionGroup::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gio" "SimpleActionGroup"+-- throws : False+-- Skip return : False++foreign import ccall "g_simple_action_group_new" g_simple_action_group_new :: +    IO (Ptr SimpleActionGroup)+++simpleActionGroupNew ::+    (MonadIO m) =>+    m SimpleActionGroup+simpleActionGroupNew  = liftIO $ do+    result <- g_simple_action_group_new+    checkUnexpectedReturnNULL "g_simple_action_group_new" result+    result' <- (wrapObject SimpleActionGroup) result+    return result'++-- method SimpleActionGroup::add_entries+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "entries", argType = TCArray False (-1) 2 (TInterface "Gio" "ActionEntry"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_entries", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "n_entries", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "entries", argType = TCArray False (-1) 2 (TInterface "Gio" "ActionEntry"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_simple_action_group_add_entries" g_simple_action_group_add_entries :: +    Ptr SimpleActionGroup ->                -- _obj : TInterface "Gio" "SimpleActionGroup"+    Ptr ActionEntry ->                      -- entries : TCArray False (-1) 2 (TInterface "Gio" "ActionEntry")+    Int32 ->                                -- n_entries : TBasicType TInt32+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()++{-# DEPRECATED simpleActionGroupAddEntries ["(Since version 2.38)","Use g_action_map_add_action_entries()"]#-}+simpleActionGroupAddEntries ::+    (MonadIO m, SimpleActionGroupK a) =>+    a ->                                    -- _obj+    [ActionEntry] ->                        -- entries+    Ptr () ->                               -- user_data+    m ()+simpleActionGroupAddEntries _obj entries user_data = liftIO $ do+    let n_entries = fromIntegral $ length entries+    let _obj' = unsafeManagedPtrCastPtr _obj+    let entries' = map unsafeManagedPtrGetPtr entries+    entries'' <- packBlockArray 64 entries'+    g_simple_action_group_add_entries _obj' entries'' n_entries user_data+    touchManagedPtr _obj+    mapM_ touchManagedPtr entries+    freeMem entries''+    return ()++-- method SimpleActionGroup::insert+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action", argType = TInterface "Gio" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action", argType = TInterface "Gio" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_simple_action_group_insert" g_simple_action_group_insert :: +    Ptr SimpleActionGroup ->                -- _obj : TInterface "Gio" "SimpleActionGroup"+    Ptr Action ->                           -- action : TInterface "Gio" "Action"+    IO ()++{-# DEPRECATED simpleActionGroupInsert ["(Since version 2.38)","Use g_action_map_add_action()"]#-}+simpleActionGroupInsert ::+    (MonadIO m, SimpleActionGroupK a, ActionK b) =>+    a ->                                    -- _obj+    b ->                                    -- action+    m ()+simpleActionGroupInsert _obj action = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let action' = unsafeManagedPtrCastPtr action+    g_simple_action_group_insert _obj' action'+    touchManagedPtr _obj+    touchManagedPtr action+    return ()++-- method SimpleActionGroup::lookup+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Action"+-- throws : False+-- Skip return : False++foreign import ccall "g_simple_action_group_lookup" g_simple_action_group_lookup :: +    Ptr SimpleActionGroup ->                -- _obj : TInterface "Gio" "SimpleActionGroup"+    CString ->                              -- action_name : TBasicType TUTF8+    IO (Ptr Action)++{-# DEPRECATED simpleActionGroupLookup ["(Since version 2.38)","Use g_action_map_lookup_action()"]#-}+simpleActionGroupLookup ::+    (MonadIO m, SimpleActionGroupK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- action_name+    m Action+simpleActionGroupLookup _obj action_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    action_name' <- textToCString action_name+    result <- g_simple_action_group_lookup _obj' action_name'+    checkUnexpectedReturnNULL "g_simple_action_group_lookup" result+    result' <- (newObject Action) result+    touchManagedPtr _obj+    freeMem action_name'+    return result'++-- method SimpleActionGroup::remove+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_simple_action_group_remove" g_simple_action_group_remove :: +    Ptr SimpleActionGroup ->                -- _obj : TInterface "Gio" "SimpleActionGroup"+    CString ->                              -- action_name : TBasicType TUTF8+    IO ()++{-# DEPRECATED simpleActionGroupRemove ["(Since version 2.38)","Use g_action_map_remove_action()"]#-}+simpleActionGroupRemove ::+    (MonadIO m, SimpleActionGroupK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- action_name+    m ()+simpleActionGroupRemove _obj action_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    action_name' <- textToCString action_name+    g_simple_action_group_remove _obj' action_name'+    touchManagedPtr _obj+    freeMem action_name'+    return ()++
+ GI/Gio/Objects/SimpleActionGroup.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Objects.SimpleActionGroup where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype SimpleActionGroup = SimpleActionGroup (ForeignPtr SimpleActionGroup)+instance GObject SimpleActionGroup where+class GObject o => SimpleActionGroupK o+instance (GObject o, IsDescendantOf SimpleActionGroup o) => SimpleActionGroupK o
+ GI/Gio/Objects/SimpleAsyncResult.hs view
@@ -0,0 +1,506 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.SimpleAsyncResult+    ( ++-- * Exported types+    SimpleAsyncResult(..)                   ,+    SimpleAsyncResultK                      ,+    toSimpleAsyncResult                     ,+    noSimpleAsyncResult                     ,+++ -- * Methods+-- ** simpleAsyncResultComplete+    simpleAsyncResultComplete               ,+++-- ** simpleAsyncResultCompleteInIdle+    simpleAsyncResultCompleteInIdle         ,+++-- ** simpleAsyncResultGetOpResGboolean+    simpleAsyncResultGetOpResGboolean       ,+++-- ** simpleAsyncResultGetOpResGssize+    simpleAsyncResultGetOpResGssize         ,+++-- ** simpleAsyncResultIsValid+    simpleAsyncResultIsValid                ,+++-- ** simpleAsyncResultNew+    simpleAsyncResultNew                    ,+++-- ** simpleAsyncResultNewFromError+    simpleAsyncResultNewFromError           ,+++-- ** simpleAsyncResultPropagateError+    simpleAsyncResultPropagateError         ,+++-- ** simpleAsyncResultSetCheckCancellable+    simpleAsyncResultSetCheckCancellable    ,+++-- ** simpleAsyncResultSetFromError+    simpleAsyncResultSetFromError           ,+++-- ** simpleAsyncResultSetHandleCancellation+    simpleAsyncResultSetHandleCancellation  ,+++-- ** simpleAsyncResultSetOpResGboolean+    simpleAsyncResultSetOpResGboolean       ,+++-- ** simpleAsyncResultSetOpResGssize+    simpleAsyncResultSetOpResGssize         ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype SimpleAsyncResult = SimpleAsyncResult (ForeignPtr SimpleAsyncResult)+foreign import ccall "g_simple_async_result_get_type"+    c_g_simple_async_result_get_type :: IO GType++type instance ParentTypes SimpleAsyncResult = SimpleAsyncResultParentTypes+type SimpleAsyncResultParentTypes = '[GObject.Object, AsyncResult]++instance GObject SimpleAsyncResult where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_simple_async_result_get_type+    ++class GObject o => SimpleAsyncResultK o+instance (GObject o, IsDescendantOf SimpleAsyncResult o) => SimpleAsyncResultK o++toSimpleAsyncResult :: SimpleAsyncResultK o => o -> IO SimpleAsyncResult+toSimpleAsyncResult = unsafeCastTo SimpleAsyncResult++noSimpleAsyncResult :: Maybe SimpleAsyncResult+noSimpleAsyncResult = Nothing++type instance AttributeList SimpleAsyncResult = SimpleAsyncResultAttributeList+type SimpleAsyncResultAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList SimpleAsyncResult = SimpleAsyncResultSignalList+type SimpleAsyncResultSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method SimpleAsyncResult::new+-- method type : Constructor+-- Args : [Arg {argName = "source_object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 2, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source_tag", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "source_object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 2, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source_tag", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SimpleAsyncResult"+-- throws : False+-- Skip return : False++foreign import ccall "g_simple_async_result_new" g_simple_async_result_new :: +    Ptr GObject.Object ->                   -- source_object : TInterface "GObject" "Object"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    Ptr () ->                               -- source_tag : TBasicType TVoid+    IO (Ptr SimpleAsyncResult)++{-# DEPRECATED simpleAsyncResultNew ["(Since version 2.46)","Use g_task_new() instead."]#-}+simpleAsyncResultNew ::+    (MonadIO m, GObject.ObjectK a) =>+    Maybe (a) ->                            -- source_object+    Maybe (AsyncReadyCallback) ->           -- callback+    Ptr () ->                               -- source_tag+    m SimpleAsyncResult+simpleAsyncResultNew source_object callback source_tag = liftIO $ do+    maybeSource_object <- case source_object of+        Nothing -> return nullPtr+        Just jSource_object -> do+            let jSource_object' = unsafeManagedPtrCastPtr jSource_object+            return jSource_object'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    result <- g_simple_async_result_new maybeSource_object maybeCallback user_data source_tag+    checkUnexpectedReturnNULL "g_simple_async_result_new" result+    result' <- (wrapObject SimpleAsyncResult) result+    whenJust source_object touchManagedPtr+    return result'++-- method SimpleAsyncResult::new_from_error+-- method type : Constructor+-- Args : [Arg {argName = "source_object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 2, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "source_object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 2, argDestroy = -1, transfer = TransferNothing},Arg {argName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SimpleAsyncResult"+-- throws : False+-- Skip return : False++foreign import ccall "g_simple_async_result_new_from_error" g_simple_async_result_new_from_error :: +    Ptr GObject.Object ->                   -- source_object : TInterface "GObject" "Object"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    Ptr GError ->                           -- error : TError+    IO (Ptr SimpleAsyncResult)++{-# DEPRECATED simpleAsyncResultNewFromError ["(Since version 2.46)","Use g_task_new() and g_task_return_error() instead."]#-}+simpleAsyncResultNewFromError ::+    (MonadIO m, GObject.ObjectK a) =>+    Maybe (a) ->                            -- source_object+    Maybe (AsyncReadyCallback) ->           -- callback+    GError ->                               -- error+    m SimpleAsyncResult+simpleAsyncResultNewFromError source_object callback error_ = liftIO $ do+    maybeSource_object <- case source_object of+        Nothing -> return nullPtr+        Just jSource_object -> do+            let jSource_object' = unsafeManagedPtrCastPtr jSource_object+            return jSource_object'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let error_' = unsafeManagedPtrGetPtr error_+    let user_data = nullPtr+    result <- g_simple_async_result_new_from_error maybeSource_object maybeCallback user_data error_'+    checkUnexpectedReturnNULL "g_simple_async_result_new_from_error" result+    result' <- (wrapObject SimpleAsyncResult) result+    whenJust source_object touchManagedPtr+    touchManagedPtr error_+    return result'++-- method SimpleAsyncResult::complete+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleAsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleAsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_simple_async_result_complete" g_simple_async_result_complete :: +    Ptr SimpleAsyncResult ->                -- _obj : TInterface "Gio" "SimpleAsyncResult"+    IO ()++{-# DEPRECATED simpleAsyncResultComplete ["(Since version 2.46)","Use #GTask instead."]#-}+simpleAsyncResultComplete ::+    (MonadIO m, SimpleAsyncResultK a) =>+    a ->                                    -- _obj+    m ()+simpleAsyncResultComplete _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_simple_async_result_complete _obj'+    touchManagedPtr _obj+    return ()++-- method SimpleAsyncResult::complete_in_idle+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleAsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleAsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_simple_async_result_complete_in_idle" g_simple_async_result_complete_in_idle :: +    Ptr SimpleAsyncResult ->                -- _obj : TInterface "Gio" "SimpleAsyncResult"+    IO ()++{-# DEPRECATED simpleAsyncResultCompleteInIdle ["(Since version 2.46)","Use #GTask instead."]#-}+simpleAsyncResultCompleteInIdle ::+    (MonadIO m, SimpleAsyncResultK a) =>+    a ->                                    -- _obj+    m ()+simpleAsyncResultCompleteInIdle _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_simple_async_result_complete_in_idle _obj'+    touchManagedPtr _obj+    return ()++-- method SimpleAsyncResult::get_op_res_gboolean+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleAsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleAsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_simple_async_result_get_op_res_gboolean" g_simple_async_result_get_op_res_gboolean :: +    Ptr SimpleAsyncResult ->                -- _obj : TInterface "Gio" "SimpleAsyncResult"+    IO CInt++{-# DEPRECATED simpleAsyncResultGetOpResGboolean ["(Since version 2.46)","Use #GTask and g_task_propagate_boolean() instead."]#-}+simpleAsyncResultGetOpResGboolean ::+    (MonadIO m, SimpleAsyncResultK a) =>+    a ->                                    -- _obj+    m Bool+simpleAsyncResultGetOpResGboolean _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_simple_async_result_get_op_res_gboolean _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method SimpleAsyncResult::get_op_res_gssize+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleAsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleAsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : False+-- Skip return : False++foreign import ccall "g_simple_async_result_get_op_res_gssize" g_simple_async_result_get_op_res_gssize :: +    Ptr SimpleAsyncResult ->                -- _obj : TInterface "Gio" "SimpleAsyncResult"+    IO Int64++{-# DEPRECATED simpleAsyncResultGetOpResGssize ["(Since version 2.46)","Use #GTask and g_task_propagate_int() instead."]#-}+simpleAsyncResultGetOpResGssize ::+    (MonadIO m, SimpleAsyncResultK a) =>+    a ->                                    -- _obj+    m Int64+simpleAsyncResultGetOpResGssize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_simple_async_result_get_op_res_gssize _obj'+    touchManagedPtr _obj+    return result++-- method SimpleAsyncResult::propagate_error+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleAsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleAsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_simple_async_result_propagate_error" g_simple_async_result_propagate_error :: +    Ptr SimpleAsyncResult ->                -- _obj : TInterface "Gio" "SimpleAsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt++{-# DEPRECATED simpleAsyncResultPropagateError ["(Since version 2.46)","Use #GTask instead."]#-}+simpleAsyncResultPropagateError ::+    (MonadIO m, SimpleAsyncResultK a) =>+    a ->                                    -- _obj+    m ()+simpleAsyncResultPropagateError _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    onException (do+        _ <- propagateGError $ g_simple_async_result_propagate_error _obj'+        touchManagedPtr _obj+        return ()+     ) (do+        return ()+     )++-- method SimpleAsyncResult::set_check_cancellable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleAsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "check_cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleAsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "check_cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_simple_async_result_set_check_cancellable" g_simple_async_result_set_check_cancellable :: +    Ptr SimpleAsyncResult ->                -- _obj : TInterface "Gio" "SimpleAsyncResult"+    Ptr Cancellable ->                      -- check_cancellable : TInterface "Gio" "Cancellable"+    IO ()++{-# DEPRECATED simpleAsyncResultSetCheckCancellable ["(Since version 2.46)","Use #GTask instead."]#-}+simpleAsyncResultSetCheckCancellable ::+    (MonadIO m, SimpleAsyncResultK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- check_cancellable+    m ()+simpleAsyncResultSetCheckCancellable _obj check_cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCheck_cancellable <- case check_cancellable of+        Nothing -> return nullPtr+        Just jCheck_cancellable -> do+            let jCheck_cancellable' = unsafeManagedPtrCastPtr jCheck_cancellable+            return jCheck_cancellable'+    g_simple_async_result_set_check_cancellable _obj' maybeCheck_cancellable+    touchManagedPtr _obj+    whenJust check_cancellable touchManagedPtr+    return ()++-- method SimpleAsyncResult::set_from_error+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleAsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleAsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_simple_async_result_set_from_error" g_simple_async_result_set_from_error :: +    Ptr SimpleAsyncResult ->                -- _obj : TInterface "Gio" "SimpleAsyncResult"+    Ptr GError ->                           -- error : TError+    IO ()++{-# DEPRECATED simpleAsyncResultSetFromError ["(Since version 2.46)","Use #GTask and g_task_return_error() instead."]#-}+simpleAsyncResultSetFromError ::+    (MonadIO m, SimpleAsyncResultK a) =>+    a ->                                    -- _obj+    GError ->                               -- error+    m ()+simpleAsyncResultSetFromError _obj error_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let error_' = unsafeManagedPtrGetPtr error_+    g_simple_async_result_set_from_error _obj' error_'+    touchManagedPtr _obj+    touchManagedPtr error_+    return ()++-- method SimpleAsyncResult::set_handle_cancellation+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleAsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "handle_cancellation", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleAsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "handle_cancellation", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_simple_async_result_set_handle_cancellation" g_simple_async_result_set_handle_cancellation :: +    Ptr SimpleAsyncResult ->                -- _obj : TInterface "Gio" "SimpleAsyncResult"+    CInt ->                                 -- handle_cancellation : TBasicType TBoolean+    IO ()++{-# DEPRECATED simpleAsyncResultSetHandleCancellation ["(Since version 2.46)"]#-}+simpleAsyncResultSetHandleCancellation ::+    (MonadIO m, SimpleAsyncResultK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- handle_cancellation+    m ()+simpleAsyncResultSetHandleCancellation _obj handle_cancellation = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let handle_cancellation' = (fromIntegral . fromEnum) handle_cancellation+    g_simple_async_result_set_handle_cancellation _obj' handle_cancellation'+    touchManagedPtr _obj+    return ()++-- method SimpleAsyncResult::set_op_res_gboolean+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleAsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "op_res", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleAsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "op_res", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_simple_async_result_set_op_res_gboolean" g_simple_async_result_set_op_res_gboolean :: +    Ptr SimpleAsyncResult ->                -- _obj : TInterface "Gio" "SimpleAsyncResult"+    CInt ->                                 -- op_res : TBasicType TBoolean+    IO ()++{-# DEPRECATED simpleAsyncResultSetOpResGboolean ["(Since version 2.46)","Use #GTask and g_task_return_boolean() instead."]#-}+simpleAsyncResultSetOpResGboolean ::+    (MonadIO m, SimpleAsyncResultK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- op_res+    m ()+simpleAsyncResultSetOpResGboolean _obj op_res = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let op_res' = (fromIntegral . fromEnum) op_res+    g_simple_async_result_set_op_res_gboolean _obj' op_res'+    touchManagedPtr _obj+    return ()++-- method SimpleAsyncResult::set_op_res_gssize+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleAsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "op_res", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleAsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "op_res", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_simple_async_result_set_op_res_gssize" g_simple_async_result_set_op_res_gssize :: +    Ptr SimpleAsyncResult ->                -- _obj : TInterface "Gio" "SimpleAsyncResult"+    Int64 ->                                -- op_res : TBasicType TInt64+    IO ()++{-# DEPRECATED simpleAsyncResultSetOpResGssize ["(Since version 2.46)","Use #GTask and g_task_return_int() instead."]#-}+simpleAsyncResultSetOpResGssize ::+    (MonadIO m, SimpleAsyncResultK a) =>+    a ->                                    -- _obj+    Int64 ->                                -- op_res+    m ()+simpleAsyncResultSetOpResGssize _obj op_res = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_simple_async_result_set_op_res_gssize _obj' op_res+    touchManagedPtr _obj+    return ()++-- method SimpleAsyncResult::is_valid+-- method type : MemberFunction+-- Args : [Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source_tag", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source_tag", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_simple_async_result_is_valid" g_simple_async_result_is_valid :: +    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr GObject.Object ->                   -- source : TInterface "GObject" "Object"+    Ptr () ->                               -- source_tag : TBasicType TVoid+    IO CInt++{-# DEPRECATED simpleAsyncResultIsValid ["(Since version 2.46)","Use #GTask and g_task_is_valid() instead."]#-}+simpleAsyncResultIsValid ::+    (MonadIO m, AsyncResultK a, GObject.ObjectK b) =>+    a ->                                    -- result+    Maybe (b) ->                            -- source+    Maybe (Ptr ()) ->                       -- source_tag+    m Bool+simpleAsyncResultIsValid result_ source source_tag = liftIO $ do+    let result_' = unsafeManagedPtrCastPtr result_+    maybeSource <- case source of+        Nothing -> return nullPtr+        Just jSource -> do+            let jSource' = unsafeManagedPtrCastPtr jSource+            return jSource'+    maybeSource_tag <- case source_tag of+        Nothing -> return nullPtr+        Just jSource_tag -> do+            return jSource_tag+    result <- g_simple_async_result_is_valid result_' maybeSource maybeSource_tag+    let result' = (/= 0) result+    touchManagedPtr result_+    whenJust source touchManagedPtr+    return result'++
+ GI/Gio/Objects/SimpleAsyncResult.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Objects.SimpleAsyncResult where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype SimpleAsyncResult = SimpleAsyncResult (ForeignPtr SimpleAsyncResult)+instance GObject SimpleAsyncResult where+class GObject o => SimpleAsyncResultK o+instance (GObject o, IsDescendantOf SimpleAsyncResult o) => SimpleAsyncResultK o
+ GI/Gio/Objects/SimpleIOStream.hs view
@@ -0,0 +1,158 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.SimpleIOStream+    ( ++-- * Exported types+    SimpleIOStream(..)                      ,+    SimpleIOStreamK                         ,+    toSimpleIOStream                        ,+    noSimpleIOStream                        ,+++ -- * Methods+-- ** simpleIOStreamNew+    simpleIOStreamNew                       ,+++++ -- * Properties+-- ** InputStream+    SimpleIOStreamInputStreamPropertyInfo   ,+    constructSimpleIOStreamInputStream      ,+    getSimpleIOStreamInputStream            ,+++-- ** OutputStream+    SimpleIOStreamOutputStreamPropertyInfo  ,+    constructSimpleIOStreamOutputStream     ,+    getSimpleIOStreamOutputStream           ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype SimpleIOStream = SimpleIOStream (ForeignPtr SimpleIOStream)+foreign import ccall "g_simple_io_stream_get_type"+    c_g_simple_io_stream_get_type :: IO GType++type instance ParentTypes SimpleIOStream = SimpleIOStreamParentTypes+type SimpleIOStreamParentTypes = '[IOStream, GObject.Object]++instance GObject SimpleIOStream where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_simple_io_stream_get_type+    ++class GObject o => SimpleIOStreamK o+instance (GObject o, IsDescendantOf SimpleIOStream o) => SimpleIOStreamK o++toSimpleIOStream :: SimpleIOStreamK o => o -> IO SimpleIOStream+toSimpleIOStream = unsafeCastTo SimpleIOStream++noSimpleIOStream :: Maybe SimpleIOStream+noSimpleIOStream = Nothing++--- XXX Duplicated object with different types:+  --- Name {namespace = "Gio", name = "SimpleIOStream"} -> Property {propName = "input-stream", propType = TInterface "Gio" "InputStream", propFlags = [PropertyReadable,PropertyWritable,PropertyConstructOnly], propTransfer = TransferNothing, propDeprecated = Nothing}+  --- Name {namespace = "Gio", name = "IOStream"} -> Property {propName = "input-stream", propType = TInterface "Gio" "InputStream", propFlags = [PropertyReadable], propTransfer = TransferNothing, propDeprecated = Nothing}+--- XXX Duplicated object with different types:+  --- Name {namespace = "Gio", name = "SimpleIOStream"} -> Property {propName = "output-stream", propType = TInterface "Gio" "OutputStream", propFlags = [PropertyReadable,PropertyWritable,PropertyConstructOnly], propTransfer = TransferNothing, propDeprecated = Nothing}+  --- Name {namespace = "Gio", name = "IOStream"} -> Property {propName = "output-stream", propType = TInterface "Gio" "OutputStream", propFlags = [PropertyReadable], propTransfer = TransferNothing, propDeprecated = Nothing}+-- VVV Prop "input-stream"+   -- Type: TInterface "Gio" "InputStream"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getSimpleIOStreamInputStream :: (MonadIO m, SimpleIOStreamK o) => o -> m InputStream+getSimpleIOStreamInputStream obj = liftIO $ getObjectPropertyObject obj "input-stream" InputStream++constructSimpleIOStreamInputStream :: (InputStreamK a) => a -> IO ([Char], GValue)+constructSimpleIOStreamInputStream val = constructObjectPropertyObject "input-stream" val++data SimpleIOStreamInputStreamPropertyInfo+instance AttrInfo SimpleIOStreamInputStreamPropertyInfo where+    type AttrAllowedOps SimpleIOStreamInputStreamPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SimpleIOStreamInputStreamPropertyInfo = InputStreamK+    type AttrBaseTypeConstraint SimpleIOStreamInputStreamPropertyInfo = SimpleIOStreamK+    type AttrGetType SimpleIOStreamInputStreamPropertyInfo = InputStream+    type AttrLabel SimpleIOStreamInputStreamPropertyInfo = "SimpleIOStream::input-stream"+    attrGet _ = getSimpleIOStreamInputStream+    attrSet _ = undefined+    attrConstruct _ = constructSimpleIOStreamInputStream++-- VVV Prop "output-stream"+   -- Type: TInterface "Gio" "OutputStream"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getSimpleIOStreamOutputStream :: (MonadIO m, SimpleIOStreamK o) => o -> m OutputStream+getSimpleIOStreamOutputStream obj = liftIO $ getObjectPropertyObject obj "output-stream" OutputStream++constructSimpleIOStreamOutputStream :: (OutputStreamK a) => a -> IO ([Char], GValue)+constructSimpleIOStreamOutputStream val = constructObjectPropertyObject "output-stream" val++data SimpleIOStreamOutputStreamPropertyInfo+instance AttrInfo SimpleIOStreamOutputStreamPropertyInfo where+    type AttrAllowedOps SimpleIOStreamOutputStreamPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SimpleIOStreamOutputStreamPropertyInfo = OutputStreamK+    type AttrBaseTypeConstraint SimpleIOStreamOutputStreamPropertyInfo = SimpleIOStreamK+    type AttrGetType SimpleIOStreamOutputStreamPropertyInfo = OutputStream+    type AttrLabel SimpleIOStreamOutputStreamPropertyInfo = "SimpleIOStream::output-stream"+    attrGet _ = getSimpleIOStreamOutputStream+    attrSet _ = undefined+    attrConstruct _ = constructSimpleIOStreamOutputStream++type instance AttributeList SimpleIOStream = SimpleIOStreamAttributeList+type SimpleIOStreamAttributeList = ('[ '("closed", IOStreamClosedPropertyInfo)] :: [(Symbol, *)])++type instance SignalList SimpleIOStream = SimpleIOStreamSignalList+type SimpleIOStreamSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method SimpleIOStream::new+-- method type : Constructor+-- Args : [Arg {argName = "input_stream", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "output_stream", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "input_stream", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "output_stream", argType = TInterface "Gio" "OutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SimpleIOStream"+-- throws : False+-- Skip return : False++foreign import ccall "g_simple_io_stream_new" g_simple_io_stream_new :: +    Ptr InputStream ->                      -- input_stream : TInterface "Gio" "InputStream"+    Ptr OutputStream ->                     -- output_stream : TInterface "Gio" "OutputStream"+    IO (Ptr SimpleIOStream)+++simpleIOStreamNew ::+    (MonadIO m, InputStreamK a, OutputStreamK b) =>+    a ->                                    -- input_stream+    b ->                                    -- output_stream+    m SimpleIOStream+simpleIOStreamNew input_stream output_stream = liftIO $ do+    let input_stream' = unsafeManagedPtrCastPtr input_stream+    let output_stream' = unsafeManagedPtrCastPtr output_stream+    result <- g_simple_io_stream_new input_stream' output_stream'+    checkUnexpectedReturnNULL "g_simple_io_stream_new" result+    result' <- (wrapObject SimpleIOStream) result+    touchManagedPtr input_stream+    touchManagedPtr output_stream+    return result'++
+ GI/Gio/Objects/SimpleIOStream.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gio.Objects.SimpleIOStream where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype SimpleIOStream = SimpleIOStream (ForeignPtr SimpleIOStream)+instance GObject SimpleIOStream where+class GObject o => SimpleIOStreamK o+instance (GObject o, IsDescendantOf SimpleIOStream o) => SimpleIOStreamK o+data SimpleIOStreamInputStreamPropertyInfo+data SimpleIOStreamOutputStreamPropertyInfo
+ GI/Gio/Objects/SimplePermission.hs view
@@ -0,0 +1,90 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.SimplePermission+    ( ++-- * Exported types+    SimplePermission(..)                    ,+    SimplePermissionK                       ,+    toSimplePermission                      ,+    noSimplePermission                      ,+++ -- * Methods+-- ** simplePermissionNew+    simplePermissionNew                     ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype SimplePermission = SimplePermission (ForeignPtr SimplePermission)+foreign import ccall "g_simple_permission_get_type"+    c_g_simple_permission_get_type :: IO GType++type instance ParentTypes SimplePermission = SimplePermissionParentTypes+type SimplePermissionParentTypes = '[Permission, GObject.Object]++instance GObject SimplePermission where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_simple_permission_get_type+    ++class GObject o => SimplePermissionK o+instance (GObject o, IsDescendantOf SimplePermission o) => SimplePermissionK o++toSimplePermission :: SimplePermissionK o => o -> IO SimplePermission+toSimplePermission = unsafeCastTo SimplePermission++noSimplePermission :: Maybe SimplePermission+noSimplePermission = Nothing++type instance AttributeList SimplePermission = SimplePermissionAttributeList+type SimplePermissionAttributeList = ('[ '("allowed", PermissionAllowedPropertyInfo), '("can-acquire", PermissionCanAcquirePropertyInfo), '("can-release", PermissionCanReleasePropertyInfo)] :: [(Symbol, *)])++type instance SignalList SimplePermission = SimplePermissionSignalList+type SimplePermissionSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method SimplePermission::new+-- method type : Constructor+-- Args : [Arg {argName = "allowed", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "allowed", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SimplePermission"+-- throws : False+-- Skip return : False++foreign import ccall "g_simple_permission_new" g_simple_permission_new :: +    CInt ->                                 -- allowed : TBasicType TBoolean+    IO (Ptr SimplePermission)+++simplePermissionNew ::+    (MonadIO m) =>+    Bool ->                                 -- allowed+    m SimplePermission+simplePermissionNew allowed = liftIO $ do+    let allowed' = (fromIntegral . fromEnum) allowed+    result <- g_simple_permission_new allowed'+    checkUnexpectedReturnNULL "g_simple_permission_new" result+    result' <- (wrapObject SimplePermission) result+    return result'++
+ GI/Gio/Objects/SimplePermission.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Objects.SimplePermission where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype SimplePermission = SimplePermission (ForeignPtr SimplePermission)+instance GObject SimplePermission where+class GObject o => SimplePermissionK o+instance (GObject o, IsDescendantOf SimplePermission o) => SimplePermissionK o
+ GI/Gio/Objects/SimpleProxyResolver.hs view
@@ -0,0 +1,268 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.SimpleProxyResolver+    ( ++-- * Exported types+    SimpleProxyResolver(..)                 ,+    SimpleProxyResolverK                    ,+    toSimpleProxyResolver                   ,+    noSimpleProxyResolver                   ,+++ -- * Methods+-- ** simpleProxyResolverNew+    simpleProxyResolverNew                  ,+++-- ** simpleProxyResolverSetDefaultProxy+    simpleProxyResolverSetDefaultProxy      ,+++-- ** simpleProxyResolverSetIgnoreHosts+    simpleProxyResolverSetIgnoreHosts       ,+++-- ** simpleProxyResolverSetUriProxy+    simpleProxyResolverSetUriProxy          ,+++++ -- * Properties+-- ** DefaultProxy+    SimpleProxyResolverDefaultProxyPropertyInfo,+    constructSimpleProxyResolverDefaultProxy,+    getSimpleProxyResolverDefaultProxy      ,+    setSimpleProxyResolverDefaultProxy      ,+++-- ** IgnoreHosts+    SimpleProxyResolverIgnoreHostsPropertyInfo,+    constructSimpleProxyResolverIgnoreHosts ,+    getSimpleProxyResolverIgnoreHosts       ,+    setSimpleProxyResolverIgnoreHosts       ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype SimpleProxyResolver = SimpleProxyResolver (ForeignPtr SimpleProxyResolver)+foreign import ccall "g_simple_proxy_resolver_get_type"+    c_g_simple_proxy_resolver_get_type :: IO GType++type instance ParentTypes SimpleProxyResolver = SimpleProxyResolverParentTypes+type SimpleProxyResolverParentTypes = '[GObject.Object, ProxyResolver]++instance GObject SimpleProxyResolver where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_simple_proxy_resolver_get_type+    ++class GObject o => SimpleProxyResolverK o+instance (GObject o, IsDescendantOf SimpleProxyResolver o) => SimpleProxyResolverK o++toSimpleProxyResolver :: SimpleProxyResolverK o => o -> IO SimpleProxyResolver+toSimpleProxyResolver = unsafeCastTo SimpleProxyResolver++noSimpleProxyResolver :: Maybe SimpleProxyResolver+noSimpleProxyResolver = Nothing++-- VVV Prop "default-proxy"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getSimpleProxyResolverDefaultProxy :: (MonadIO m, SimpleProxyResolverK o) => o -> m T.Text+getSimpleProxyResolverDefaultProxy obj = liftIO $ getObjectPropertyString obj "default-proxy"++setSimpleProxyResolverDefaultProxy :: (MonadIO m, SimpleProxyResolverK o) => o -> T.Text -> m ()+setSimpleProxyResolverDefaultProxy obj val = liftIO $ setObjectPropertyString obj "default-proxy" val++constructSimpleProxyResolverDefaultProxy :: T.Text -> IO ([Char], GValue)+constructSimpleProxyResolverDefaultProxy val = constructObjectPropertyString "default-proxy" val++data SimpleProxyResolverDefaultProxyPropertyInfo+instance AttrInfo SimpleProxyResolverDefaultProxyPropertyInfo where+    type AttrAllowedOps SimpleProxyResolverDefaultProxyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SimpleProxyResolverDefaultProxyPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint SimpleProxyResolverDefaultProxyPropertyInfo = SimpleProxyResolverK+    type AttrGetType SimpleProxyResolverDefaultProxyPropertyInfo = T.Text+    type AttrLabel SimpleProxyResolverDefaultProxyPropertyInfo = "SimpleProxyResolver::default-proxy"+    attrGet _ = getSimpleProxyResolverDefaultProxy+    attrSet _ = setSimpleProxyResolverDefaultProxy+    attrConstruct _ = constructSimpleProxyResolverDefaultProxy++-- VVV Prop "ignore-hosts"+   -- Type: TCArray True (-1) (-1) (TBasicType TUTF8)+   -- Flags: [PropertyReadable,PropertyWritable]++getSimpleProxyResolverIgnoreHosts :: (MonadIO m, SimpleProxyResolverK o) => o -> m [T.Text]+getSimpleProxyResolverIgnoreHosts obj = liftIO $ getObjectPropertyStringArray obj "ignore-hosts"++setSimpleProxyResolverIgnoreHosts :: (MonadIO m, SimpleProxyResolverK o) => o -> [T.Text] -> m ()+setSimpleProxyResolverIgnoreHosts obj val = liftIO $ setObjectPropertyStringArray obj "ignore-hosts" val++constructSimpleProxyResolverIgnoreHosts :: [T.Text] -> IO ([Char], GValue)+constructSimpleProxyResolverIgnoreHosts val = constructObjectPropertyStringArray "ignore-hosts" val++data SimpleProxyResolverIgnoreHostsPropertyInfo+instance AttrInfo SimpleProxyResolverIgnoreHostsPropertyInfo where+    type AttrAllowedOps SimpleProxyResolverIgnoreHostsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SimpleProxyResolverIgnoreHostsPropertyInfo = (~) [T.Text]+    type AttrBaseTypeConstraint SimpleProxyResolverIgnoreHostsPropertyInfo = SimpleProxyResolverK+    type AttrGetType SimpleProxyResolverIgnoreHostsPropertyInfo = [T.Text]+    type AttrLabel SimpleProxyResolverIgnoreHostsPropertyInfo = "SimpleProxyResolver::ignore-hosts"+    attrGet _ = getSimpleProxyResolverIgnoreHosts+    attrSet _ = setSimpleProxyResolverIgnoreHosts+    attrConstruct _ = constructSimpleProxyResolverIgnoreHosts++type instance AttributeList SimpleProxyResolver = SimpleProxyResolverAttributeList+type SimpleProxyResolverAttributeList = ('[ '("default-proxy", SimpleProxyResolverDefaultProxyPropertyInfo), '("ignore-hosts", SimpleProxyResolverIgnoreHostsPropertyInfo)] :: [(Symbol, *)])++type instance SignalList SimpleProxyResolver = SimpleProxyResolverSignalList+type SimpleProxyResolverSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method SimpleProxyResolver::set_default_proxy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleProxyResolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "default_proxy", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleProxyResolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "default_proxy", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_simple_proxy_resolver_set_default_proxy" g_simple_proxy_resolver_set_default_proxy :: +    Ptr SimpleProxyResolver ->              -- _obj : TInterface "Gio" "SimpleProxyResolver"+    CString ->                              -- default_proxy : TBasicType TUTF8+    IO ()+++simpleProxyResolverSetDefaultProxy ::+    (MonadIO m, SimpleProxyResolverK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- default_proxy+    m ()+simpleProxyResolverSetDefaultProxy _obj default_proxy = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    default_proxy' <- textToCString default_proxy+    g_simple_proxy_resolver_set_default_proxy _obj' default_proxy'+    touchManagedPtr _obj+    freeMem default_proxy'+    return ()++-- method SimpleProxyResolver::set_ignore_hosts+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleProxyResolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "ignore_hosts", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleProxyResolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "ignore_hosts", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_simple_proxy_resolver_set_ignore_hosts" g_simple_proxy_resolver_set_ignore_hosts :: +    Ptr SimpleProxyResolver ->              -- _obj : TInterface "Gio" "SimpleProxyResolver"+    CString ->                              -- ignore_hosts : TBasicType TUTF8+    IO ()+++simpleProxyResolverSetIgnoreHosts ::+    (MonadIO m, SimpleProxyResolverK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- ignore_hosts+    m ()+simpleProxyResolverSetIgnoreHosts _obj ignore_hosts = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    ignore_hosts' <- textToCString ignore_hosts+    g_simple_proxy_resolver_set_ignore_hosts _obj' ignore_hosts'+    touchManagedPtr _obj+    freeMem ignore_hosts'+    return ()++-- method SimpleProxyResolver::set_uri_proxy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleProxyResolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "uri_scheme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "proxy", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SimpleProxyResolver", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "uri_scheme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "proxy", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_simple_proxy_resolver_set_uri_proxy" g_simple_proxy_resolver_set_uri_proxy :: +    Ptr SimpleProxyResolver ->              -- _obj : TInterface "Gio" "SimpleProxyResolver"+    CString ->                              -- uri_scheme : TBasicType TUTF8+    CString ->                              -- proxy : TBasicType TUTF8+    IO ()+++simpleProxyResolverSetUriProxy ::+    (MonadIO m, SimpleProxyResolverK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- uri_scheme+    T.Text ->                               -- proxy+    m ()+simpleProxyResolverSetUriProxy _obj uri_scheme proxy = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    uri_scheme' <- textToCString uri_scheme+    proxy' <- textToCString proxy+    g_simple_proxy_resolver_set_uri_proxy _obj' uri_scheme' proxy'+    touchManagedPtr _obj+    freeMem uri_scheme'+    freeMem proxy'+    return ()++-- method SimpleProxyResolver::new+-- method type : MemberFunction+-- Args : [Arg {argName = "default_proxy", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "ignore_hosts", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "default_proxy", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "ignore_hosts", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "ProxyResolver"+-- throws : False+-- Skip return : False++foreign import ccall "g_simple_proxy_resolver_new" g_simple_proxy_resolver_new :: +    CString ->                              -- default_proxy : TBasicType TUTF8+    CString ->                              -- ignore_hosts : TBasicType TUTF8+    IO (Ptr ProxyResolver)+++simpleProxyResolverNew ::+    (MonadIO m) =>+    Maybe (T.Text) ->                       -- default_proxy+    Maybe (T.Text) ->                       -- ignore_hosts+    m ProxyResolver+simpleProxyResolverNew default_proxy ignore_hosts = liftIO $ do+    maybeDefault_proxy <- case default_proxy of+        Nothing -> return nullPtr+        Just jDefault_proxy -> do+            jDefault_proxy' <- textToCString jDefault_proxy+            return jDefault_proxy'+    maybeIgnore_hosts <- case ignore_hosts of+        Nothing -> return nullPtr+        Just jIgnore_hosts -> do+            jIgnore_hosts' <- textToCString jIgnore_hosts+            return jIgnore_hosts'+    result <- g_simple_proxy_resolver_new maybeDefault_proxy maybeIgnore_hosts+    checkUnexpectedReturnNULL "g_simple_proxy_resolver_new" result+    result' <- (wrapObject ProxyResolver) result+    freeMem maybeDefault_proxy+    freeMem maybeIgnore_hosts+    return result'++
+ GI/Gio/Objects/SimpleProxyResolver.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gio.Objects.SimpleProxyResolver where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype SimpleProxyResolver = SimpleProxyResolver (ForeignPtr SimpleProxyResolver)+instance GObject SimpleProxyResolver where+class GObject o => SimpleProxyResolverK o+instance (GObject o, IsDescendantOf SimpleProxyResolver o) => SimpleProxyResolverK o+data SimpleProxyResolverDefaultProxyPropertyInfo+data SimpleProxyResolverIgnoreHostsPropertyInfo
+ GI/Gio/Objects/Socket.hs view
@@ -0,0 +1,2440 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.Socket+    ( ++-- * Exported types+    Socket(..)                              ,+    SocketK                                 ,+    toSocket                                ,+    noSocket                                ,+++ -- * Methods+-- ** socketAccept+    socketAccept                            ,+++-- ** socketBind+    socketBind                              ,+++-- ** socketCheckConnectResult+    socketCheckConnectResult                ,+++-- ** socketClose+    socketClose                             ,+++-- ** socketConditionCheck+    socketConditionCheck                    ,+++-- ** socketConditionTimedWait+    socketConditionTimedWait                ,+++-- ** socketConditionWait+    socketConditionWait                     ,+++-- ** socketConnect+    socketConnect                           ,+++-- ** socketConnectionFactoryCreateConnection+    socketConnectionFactoryCreateConnection ,+++-- ** socketGetAvailableBytes+    socketGetAvailableBytes                 ,+++-- ** socketGetBlocking+    socketGetBlocking                       ,+++-- ** socketGetBroadcast+    socketGetBroadcast                      ,+++-- ** socketGetCredentials+    socketGetCredentials                    ,+++-- ** socketGetFamily+    socketGetFamily                         ,+++-- ** socketGetFd+    socketGetFd                             ,+++-- ** socketGetKeepalive+    socketGetKeepalive                      ,+++-- ** socketGetListenBacklog+    socketGetListenBacklog                  ,+++-- ** socketGetLocalAddress+    socketGetLocalAddress                   ,+++-- ** socketGetMulticastLoopback+    socketGetMulticastLoopback              ,+++-- ** socketGetMulticastTtl+    socketGetMulticastTtl                   ,+++-- ** socketGetOption+    socketGetOption                         ,+++-- ** socketGetProtocol+    socketGetProtocol                       ,+++-- ** socketGetRemoteAddress+    socketGetRemoteAddress                  ,+++-- ** socketGetSocketType+    socketGetSocketType                     ,+++-- ** socketGetTimeout+    socketGetTimeout                        ,+++-- ** socketGetTtl+    socketGetTtl                            ,+++-- ** socketIsClosed+    socketIsClosed                          ,+++-- ** socketIsConnected+    socketIsConnected                       ,+++-- ** socketJoinMulticastGroup+    socketJoinMulticastGroup                ,+++-- ** socketLeaveMulticastGroup+    socketLeaveMulticastGroup               ,+++-- ** socketListen+    socketListen                            ,+++-- ** socketNew+    socketNew                               ,+++-- ** socketNewFromFd+    socketNewFromFd                         ,+++-- ** socketReceive+    socketReceive                           ,+++-- ** socketReceiveFrom+    socketReceiveFrom                       ,+++-- ** socketReceiveMessage+    socketReceiveMessage                    ,+++-- ** socketReceiveWithBlocking+    socketReceiveWithBlocking               ,+++-- ** socketSend+    socketSend                              ,+++-- ** socketSendMessage+    socketSendMessage                       ,+++-- ** socketSendMessages+    socketSendMessages                      ,+++-- ** socketSendTo+    socketSendTo                            ,+++-- ** socketSendWithBlocking+    socketSendWithBlocking                  ,+++-- ** socketSetBlocking+    socketSetBlocking                       ,+++-- ** socketSetBroadcast+    socketSetBroadcast                      ,+++-- ** socketSetKeepalive+    socketSetKeepalive                      ,+++-- ** socketSetListenBacklog+    socketSetListenBacklog                  ,+++-- ** socketSetMulticastLoopback+    socketSetMulticastLoopback              ,+++-- ** socketSetMulticastTtl+    socketSetMulticastTtl                   ,+++-- ** socketSetOption+    socketSetOption                         ,+++-- ** socketSetTimeout+    socketSetTimeout                        ,+++-- ** socketSetTtl+    socketSetTtl                            ,+++-- ** socketShutdown+    socketShutdown                          ,+++-- ** socketSpeaksIpv4+    socketSpeaksIpv4                        ,+++++ -- * Properties+-- ** Blocking+    SocketBlockingPropertyInfo              ,+    constructSocketBlocking                 ,+    getSocketBlocking                       ,+    setSocketBlocking                       ,+++-- ** Broadcast+    SocketBroadcastPropertyInfo             ,+    constructSocketBroadcast                ,+    getSocketBroadcast                      ,+    setSocketBroadcast                      ,+++-- ** Family+    SocketFamilyPropertyInfo                ,+    constructSocketFamily                   ,+    getSocketFamily                         ,+++-- ** Fd+    SocketFdPropertyInfo                    ,+    constructSocketFd                       ,+    getSocketFd                             ,+++-- ** Keepalive+    SocketKeepalivePropertyInfo             ,+    constructSocketKeepalive                ,+    getSocketKeepalive                      ,+    setSocketKeepalive                      ,+++-- ** ListenBacklog+    SocketListenBacklogPropertyInfo         ,+    constructSocketListenBacklog            ,+    getSocketListenBacklog                  ,+    setSocketListenBacklog                  ,+++-- ** LocalAddress+    SocketLocalAddressPropertyInfo          ,+    getSocketLocalAddress                   ,+++-- ** MulticastLoopback+    SocketMulticastLoopbackPropertyInfo     ,+    constructSocketMulticastLoopback        ,+    getSocketMulticastLoopback              ,+    setSocketMulticastLoopback              ,+++-- ** MulticastTtl+    SocketMulticastTtlPropertyInfo          ,+    constructSocketMulticastTtl             ,+    getSocketMulticastTtl                   ,+    setSocketMulticastTtl                   ,+++-- ** Protocol+    SocketProtocolPropertyInfo              ,+    constructSocketProtocol                 ,+    getSocketProtocol                       ,+++-- ** RemoteAddress+    SocketRemoteAddressPropertyInfo         ,+    getSocketRemoteAddress                  ,+++-- ** Timeout+    SocketTimeoutPropertyInfo               ,+    constructSocketTimeout                  ,+    getSocketTimeout                        ,+    setSocketTimeout                        ,+++-- ** Ttl+    SocketTtlPropertyInfo                   ,+    constructSocketTtl                      ,+    getSocketTtl                            ,+    setSocketTtl                            ,+++-- ** Type+    SocketTypePropertyInfo                  ,+    constructSocketType                     ,+    getSocketType                           ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype Socket = Socket (ForeignPtr Socket)+foreign import ccall "g_socket_get_type"+    c_g_socket_get_type :: IO GType++type instance ParentTypes Socket = SocketParentTypes+type SocketParentTypes = '[GObject.Object, Initable]++instance GObject Socket where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_socket_get_type+    ++class GObject o => SocketK o+instance (GObject o, IsDescendantOf Socket o) => SocketK o++toSocket :: SocketK o => o -> IO Socket+toSocket = unsafeCastTo Socket++noSocket :: Maybe Socket+noSocket = Nothing++-- VVV Prop "blocking"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getSocketBlocking :: (MonadIO m, SocketK o) => o -> m Bool+getSocketBlocking obj = liftIO $ getObjectPropertyBool obj "blocking"++setSocketBlocking :: (MonadIO m, SocketK o) => o -> Bool -> m ()+setSocketBlocking obj val = liftIO $ setObjectPropertyBool obj "blocking" val++constructSocketBlocking :: Bool -> IO ([Char], GValue)+constructSocketBlocking val = constructObjectPropertyBool "blocking" val++data SocketBlockingPropertyInfo+instance AttrInfo SocketBlockingPropertyInfo where+    type AttrAllowedOps SocketBlockingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SocketBlockingPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint SocketBlockingPropertyInfo = SocketK+    type AttrGetType SocketBlockingPropertyInfo = Bool+    type AttrLabel SocketBlockingPropertyInfo = "Socket::blocking"+    attrGet _ = getSocketBlocking+    attrSet _ = setSocketBlocking+    attrConstruct _ = constructSocketBlocking++-- VVV Prop "broadcast"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getSocketBroadcast :: (MonadIO m, SocketK o) => o -> m Bool+getSocketBroadcast obj = liftIO $ getObjectPropertyBool obj "broadcast"++setSocketBroadcast :: (MonadIO m, SocketK o) => o -> Bool -> m ()+setSocketBroadcast obj val = liftIO $ setObjectPropertyBool obj "broadcast" val++constructSocketBroadcast :: Bool -> IO ([Char], GValue)+constructSocketBroadcast val = constructObjectPropertyBool "broadcast" val++data SocketBroadcastPropertyInfo+instance AttrInfo SocketBroadcastPropertyInfo where+    type AttrAllowedOps SocketBroadcastPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SocketBroadcastPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint SocketBroadcastPropertyInfo = SocketK+    type AttrGetType SocketBroadcastPropertyInfo = Bool+    type AttrLabel SocketBroadcastPropertyInfo = "Socket::broadcast"+    attrGet _ = getSocketBroadcast+    attrSet _ = setSocketBroadcast+    attrConstruct _ = constructSocketBroadcast++-- VVV Prop "family"+   -- Type: TInterface "Gio" "SocketFamily"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getSocketFamily :: (MonadIO m, SocketK o) => o -> m SocketFamily+getSocketFamily obj = liftIO $ getObjectPropertyEnum obj "family"++constructSocketFamily :: SocketFamily -> IO ([Char], GValue)+constructSocketFamily val = constructObjectPropertyEnum "family" val++data SocketFamilyPropertyInfo+instance AttrInfo SocketFamilyPropertyInfo where+    type AttrAllowedOps SocketFamilyPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SocketFamilyPropertyInfo = (~) SocketFamily+    type AttrBaseTypeConstraint SocketFamilyPropertyInfo = SocketK+    type AttrGetType SocketFamilyPropertyInfo = SocketFamily+    type AttrLabel SocketFamilyPropertyInfo = "Socket::family"+    attrGet _ = getSocketFamily+    attrSet _ = undefined+    attrConstruct _ = constructSocketFamily++-- VVV Prop "fd"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getSocketFd :: (MonadIO m, SocketK o) => o -> m Int32+getSocketFd obj = liftIO $ getObjectPropertyCInt obj "fd"++constructSocketFd :: Int32 -> IO ([Char], GValue)+constructSocketFd val = constructObjectPropertyCInt "fd" val++data SocketFdPropertyInfo+instance AttrInfo SocketFdPropertyInfo where+    type AttrAllowedOps SocketFdPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SocketFdPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint SocketFdPropertyInfo = SocketK+    type AttrGetType SocketFdPropertyInfo = Int32+    type AttrLabel SocketFdPropertyInfo = "Socket::fd"+    attrGet _ = getSocketFd+    attrSet _ = undefined+    attrConstruct _ = constructSocketFd++-- VVV Prop "keepalive"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getSocketKeepalive :: (MonadIO m, SocketK o) => o -> m Bool+getSocketKeepalive obj = liftIO $ getObjectPropertyBool obj "keepalive"++setSocketKeepalive :: (MonadIO m, SocketK o) => o -> Bool -> m ()+setSocketKeepalive obj val = liftIO $ setObjectPropertyBool obj "keepalive" val++constructSocketKeepalive :: Bool -> IO ([Char], GValue)+constructSocketKeepalive val = constructObjectPropertyBool "keepalive" val++data SocketKeepalivePropertyInfo+instance AttrInfo SocketKeepalivePropertyInfo where+    type AttrAllowedOps SocketKeepalivePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SocketKeepalivePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint SocketKeepalivePropertyInfo = SocketK+    type AttrGetType SocketKeepalivePropertyInfo = Bool+    type AttrLabel SocketKeepalivePropertyInfo = "Socket::keepalive"+    attrGet _ = getSocketKeepalive+    attrSet _ = setSocketKeepalive+    attrConstruct _ = constructSocketKeepalive++-- VVV Prop "listen-backlog"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getSocketListenBacklog :: (MonadIO m, SocketK o) => o -> m Int32+getSocketListenBacklog obj = liftIO $ getObjectPropertyCInt obj "listen-backlog"++setSocketListenBacklog :: (MonadIO m, SocketK o) => o -> Int32 -> m ()+setSocketListenBacklog obj val = liftIO $ setObjectPropertyCInt obj "listen-backlog" val++constructSocketListenBacklog :: Int32 -> IO ([Char], GValue)+constructSocketListenBacklog val = constructObjectPropertyCInt "listen-backlog" val++data SocketListenBacklogPropertyInfo+instance AttrInfo SocketListenBacklogPropertyInfo where+    type AttrAllowedOps SocketListenBacklogPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SocketListenBacklogPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint SocketListenBacklogPropertyInfo = SocketK+    type AttrGetType SocketListenBacklogPropertyInfo = Int32+    type AttrLabel SocketListenBacklogPropertyInfo = "Socket::listen-backlog"+    attrGet _ = getSocketListenBacklog+    attrSet _ = setSocketListenBacklog+    attrConstruct _ = constructSocketListenBacklog++-- VVV Prop "local-address"+   -- Type: TInterface "Gio" "SocketAddress"+   -- Flags: [PropertyReadable]++getSocketLocalAddress :: (MonadIO m, SocketK o) => o -> m SocketAddress+getSocketLocalAddress obj = liftIO $ getObjectPropertyObject obj "local-address" SocketAddress++data SocketLocalAddressPropertyInfo+instance AttrInfo SocketLocalAddressPropertyInfo where+    type AttrAllowedOps SocketLocalAddressPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint SocketLocalAddressPropertyInfo = (~) ()+    type AttrBaseTypeConstraint SocketLocalAddressPropertyInfo = SocketK+    type AttrGetType SocketLocalAddressPropertyInfo = SocketAddress+    type AttrLabel SocketLocalAddressPropertyInfo = "Socket::local-address"+    attrGet _ = getSocketLocalAddress+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "multicast-loopback"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getSocketMulticastLoopback :: (MonadIO m, SocketK o) => o -> m Bool+getSocketMulticastLoopback obj = liftIO $ getObjectPropertyBool obj "multicast-loopback"++setSocketMulticastLoopback :: (MonadIO m, SocketK o) => o -> Bool -> m ()+setSocketMulticastLoopback obj val = liftIO $ setObjectPropertyBool obj "multicast-loopback" val++constructSocketMulticastLoopback :: Bool -> IO ([Char], GValue)+constructSocketMulticastLoopback val = constructObjectPropertyBool "multicast-loopback" val++data SocketMulticastLoopbackPropertyInfo+instance AttrInfo SocketMulticastLoopbackPropertyInfo where+    type AttrAllowedOps SocketMulticastLoopbackPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SocketMulticastLoopbackPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint SocketMulticastLoopbackPropertyInfo = SocketK+    type AttrGetType SocketMulticastLoopbackPropertyInfo = Bool+    type AttrLabel SocketMulticastLoopbackPropertyInfo = "Socket::multicast-loopback"+    attrGet _ = getSocketMulticastLoopback+    attrSet _ = setSocketMulticastLoopback+    attrConstruct _ = constructSocketMulticastLoopback++-- VVV Prop "multicast-ttl"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getSocketMulticastTtl :: (MonadIO m, SocketK o) => o -> m Word32+getSocketMulticastTtl obj = liftIO $ getObjectPropertyCUInt obj "multicast-ttl"++setSocketMulticastTtl :: (MonadIO m, SocketK o) => o -> Word32 -> m ()+setSocketMulticastTtl obj val = liftIO $ setObjectPropertyCUInt obj "multicast-ttl" val++constructSocketMulticastTtl :: Word32 -> IO ([Char], GValue)+constructSocketMulticastTtl val = constructObjectPropertyCUInt "multicast-ttl" val++data SocketMulticastTtlPropertyInfo+instance AttrInfo SocketMulticastTtlPropertyInfo where+    type AttrAllowedOps SocketMulticastTtlPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SocketMulticastTtlPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint SocketMulticastTtlPropertyInfo = SocketK+    type AttrGetType SocketMulticastTtlPropertyInfo = Word32+    type AttrLabel SocketMulticastTtlPropertyInfo = "Socket::multicast-ttl"+    attrGet _ = getSocketMulticastTtl+    attrSet _ = setSocketMulticastTtl+    attrConstruct _ = constructSocketMulticastTtl++-- VVV Prop "protocol"+   -- Type: TInterface "Gio" "SocketProtocol"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getSocketProtocol :: (MonadIO m, SocketK o) => o -> m SocketProtocol+getSocketProtocol obj = liftIO $ getObjectPropertyEnum obj "protocol"++constructSocketProtocol :: SocketProtocol -> IO ([Char], GValue)+constructSocketProtocol val = constructObjectPropertyEnum "protocol" val++data SocketProtocolPropertyInfo+instance AttrInfo SocketProtocolPropertyInfo where+    type AttrAllowedOps SocketProtocolPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SocketProtocolPropertyInfo = (~) SocketProtocol+    type AttrBaseTypeConstraint SocketProtocolPropertyInfo = SocketK+    type AttrGetType SocketProtocolPropertyInfo = SocketProtocol+    type AttrLabel SocketProtocolPropertyInfo = "Socket::protocol"+    attrGet _ = getSocketProtocol+    attrSet _ = undefined+    attrConstruct _ = constructSocketProtocol++-- VVV Prop "remote-address"+   -- Type: TInterface "Gio" "SocketAddress"+   -- Flags: [PropertyReadable]++getSocketRemoteAddress :: (MonadIO m, SocketK o) => o -> m SocketAddress+getSocketRemoteAddress obj = liftIO $ getObjectPropertyObject obj "remote-address" SocketAddress++data SocketRemoteAddressPropertyInfo+instance AttrInfo SocketRemoteAddressPropertyInfo where+    type AttrAllowedOps SocketRemoteAddressPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint SocketRemoteAddressPropertyInfo = (~) ()+    type AttrBaseTypeConstraint SocketRemoteAddressPropertyInfo = SocketK+    type AttrGetType SocketRemoteAddressPropertyInfo = SocketAddress+    type AttrLabel SocketRemoteAddressPropertyInfo = "Socket::remote-address"+    attrGet _ = getSocketRemoteAddress+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "timeout"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getSocketTimeout :: (MonadIO m, SocketK o) => o -> m Word32+getSocketTimeout obj = liftIO $ getObjectPropertyCUInt obj "timeout"++setSocketTimeout :: (MonadIO m, SocketK o) => o -> Word32 -> m ()+setSocketTimeout obj val = liftIO $ setObjectPropertyCUInt obj "timeout" val++constructSocketTimeout :: Word32 -> IO ([Char], GValue)+constructSocketTimeout val = constructObjectPropertyCUInt "timeout" val++data SocketTimeoutPropertyInfo+instance AttrInfo SocketTimeoutPropertyInfo where+    type AttrAllowedOps SocketTimeoutPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SocketTimeoutPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint SocketTimeoutPropertyInfo = SocketK+    type AttrGetType SocketTimeoutPropertyInfo = Word32+    type AttrLabel SocketTimeoutPropertyInfo = "Socket::timeout"+    attrGet _ = getSocketTimeout+    attrSet _ = setSocketTimeout+    attrConstruct _ = constructSocketTimeout++-- VVV Prop "ttl"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getSocketTtl :: (MonadIO m, SocketK o) => o -> m Word32+getSocketTtl obj = liftIO $ getObjectPropertyCUInt obj "ttl"++setSocketTtl :: (MonadIO m, SocketK o) => o -> Word32 -> m ()+setSocketTtl obj val = liftIO $ setObjectPropertyCUInt obj "ttl" val++constructSocketTtl :: Word32 -> IO ([Char], GValue)+constructSocketTtl val = constructObjectPropertyCUInt "ttl" val++data SocketTtlPropertyInfo+instance AttrInfo SocketTtlPropertyInfo where+    type AttrAllowedOps SocketTtlPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SocketTtlPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint SocketTtlPropertyInfo = SocketK+    type AttrGetType SocketTtlPropertyInfo = Word32+    type AttrLabel SocketTtlPropertyInfo = "Socket::ttl"+    attrGet _ = getSocketTtl+    attrSet _ = setSocketTtl+    attrConstruct _ = constructSocketTtl++-- VVV Prop "type"+   -- Type: TInterface "Gio" "SocketType"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getSocketType :: (MonadIO m, SocketK o) => o -> m SocketType+getSocketType obj = liftIO $ getObjectPropertyEnum obj "type"++constructSocketType :: SocketType -> IO ([Char], GValue)+constructSocketType val = constructObjectPropertyEnum "type" val++data SocketTypePropertyInfo+instance AttrInfo SocketTypePropertyInfo where+    type AttrAllowedOps SocketTypePropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SocketTypePropertyInfo = (~) SocketType+    type AttrBaseTypeConstraint SocketTypePropertyInfo = SocketK+    type AttrGetType SocketTypePropertyInfo = SocketType+    type AttrLabel SocketTypePropertyInfo = "Socket::type"+    attrGet _ = getSocketType+    attrSet _ = undefined+    attrConstruct _ = constructSocketType++type instance AttributeList Socket = SocketAttributeList+type SocketAttributeList = ('[ '("blocking", SocketBlockingPropertyInfo), '("broadcast", SocketBroadcastPropertyInfo), '("family", SocketFamilyPropertyInfo), '("fd", SocketFdPropertyInfo), '("keepalive", SocketKeepalivePropertyInfo), '("listen-backlog", SocketListenBacklogPropertyInfo), '("local-address", SocketLocalAddressPropertyInfo), '("multicast-loopback", SocketMulticastLoopbackPropertyInfo), '("multicast-ttl", SocketMulticastTtlPropertyInfo), '("protocol", SocketProtocolPropertyInfo), '("remote-address", SocketRemoteAddressPropertyInfo), '("timeout", SocketTimeoutPropertyInfo), '("ttl", SocketTtlPropertyInfo), '("type", SocketTypePropertyInfo)] :: [(Symbol, *)])++type instance SignalList Socket = SocketSignalList+type SocketSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Socket::new+-- method type : Constructor+-- Args : [Arg {argName = "family", argType = TInterface "Gio" "SocketFamily", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "Gio" "SocketType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "protocol", argType = TInterface "Gio" "SocketProtocol", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "family", argType = TInterface "Gio" "SocketFamily", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "Gio" "SocketType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "protocol", argType = TInterface "Gio" "SocketProtocol", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Socket"+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_new" g_socket_new :: +    CUInt ->                                -- family : TInterface "Gio" "SocketFamily"+    CUInt ->                                -- type : TInterface "Gio" "SocketType"+    CUInt ->                                -- protocol : TInterface "Gio" "SocketProtocol"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Socket)+++socketNew ::+    (MonadIO m) =>+    SocketFamily ->                         -- family+    SocketType ->                           -- type+    SocketProtocol ->                       -- protocol+    m Socket+socketNew family type_ protocol = liftIO $ do+    let family' = (fromIntegral . fromEnum) family+    let type_' = (fromIntegral . fromEnum) type_+    let protocol' = (fromIntegral . fromEnum) protocol+    onException (do+        result <- propagateGError $ g_socket_new family' type_' protocol'+        checkUnexpectedReturnNULL "g_socket_new" result+        result' <- (wrapObject Socket) result+        return result'+     ) (do+        return ()+     )++-- method Socket::new_from_fd+-- method type : Constructor+-- Args : [Arg {argName = "fd", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "fd", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Socket"+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_new_from_fd" g_socket_new_from_fd :: +    Int32 ->                                -- fd : TBasicType TInt32+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Socket)+++socketNewFromFd ::+    (MonadIO m) =>+    Int32 ->                                -- fd+    m Socket+socketNewFromFd fd = liftIO $ do+    onException (do+        result <- propagateGError $ g_socket_new_from_fd fd+        checkUnexpectedReturnNULL "g_socket_new_from_fd" result+        result' <- (wrapObject Socket) result+        return result'+     ) (do+        return ()+     )++-- method Socket::accept+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Socket"+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_accept" g_socket_accept :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Socket)+++socketAccept ::+    (MonadIO m, SocketK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m Socket+socketAccept _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_socket_accept _obj' maybeCancellable+        checkUnexpectedReturnNULL "g_socket_accept" result+        result' <- (wrapObject Socket) result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )++-- method Socket::bind+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "address", argType = TInterface "Gio" "SocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "allow_reuse", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "address", argType = TInterface "Gio" "SocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "allow_reuse", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_bind" g_socket_bind :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    Ptr SocketAddress ->                    -- address : TInterface "Gio" "SocketAddress"+    CInt ->                                 -- allow_reuse : TBasicType TBoolean+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++socketBind ::+    (MonadIO m, SocketK a, SocketAddressK b) =>+    a ->                                    -- _obj+    b ->                                    -- address+    Bool ->                                 -- allow_reuse+    m ()+socketBind _obj address allow_reuse = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let address' = unsafeManagedPtrCastPtr address+    let allow_reuse' = (fromIntegral . fromEnum) allow_reuse+    onException (do+        _ <- propagateGError $ g_socket_bind _obj' address' allow_reuse'+        touchManagedPtr _obj+        touchManagedPtr address+        return ()+     ) (do+        return ()+     )++-- method Socket::check_connect_result+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_check_connect_result" g_socket_check_connect_result :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++socketCheckConnectResult ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    m ()+socketCheckConnectResult _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    onException (do+        _ <- propagateGError $ g_socket_check_connect_result _obj'+        touchManagedPtr _obj+        return ()+     ) (do+        return ()+     )++-- method Socket::close+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_close" g_socket_close :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++socketClose ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    m ()+socketClose _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    onException (do+        _ <- propagateGError $ g_socket_close _obj'+        touchManagedPtr _obj+        return ()+     ) (do+        return ()+     )++-- method Socket::condition_check+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "condition", argType = TInterface "GLib" "IOCondition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "condition", argType = TInterface "GLib" "IOCondition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GLib" "IOCondition"+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_condition_check" g_socket_condition_check :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    CUInt ->                                -- condition : TInterface "GLib" "IOCondition"+    IO CUInt+++socketConditionCheck ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    [GLib.IOCondition] ->                   -- condition+    m [GLib.IOCondition]+socketConditionCheck _obj condition = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let condition' = gflagsToWord condition+    result <- g_socket_condition_check _obj' condition'+    let result' = wordToGFlags result+    touchManagedPtr _obj+    return result'++-- method Socket::condition_timed_wait+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "condition", argType = TInterface "GLib" "IOCondition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "timeout", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "condition", argType = TInterface "GLib" "IOCondition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "timeout", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_condition_timed_wait" g_socket_condition_timed_wait :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    CUInt ->                                -- condition : TInterface "GLib" "IOCondition"+    Int64 ->                                -- timeout : TBasicType TInt64+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++socketConditionTimedWait ::+    (MonadIO m, SocketK a, CancellableK b) =>+    a ->                                    -- _obj+    [GLib.IOCondition] ->                   -- condition+    Int64 ->                                -- timeout+    Maybe (b) ->                            -- cancellable+    m ()+socketConditionTimedWait _obj condition timeout cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let condition' = gflagsToWord condition+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_socket_condition_timed_wait _obj' condition' timeout maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method Socket::condition_wait+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "condition", argType = TInterface "GLib" "IOCondition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "condition", argType = TInterface "GLib" "IOCondition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_condition_wait" g_socket_condition_wait :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    CUInt ->                                -- condition : TInterface "GLib" "IOCondition"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++socketConditionWait ::+    (MonadIO m, SocketK a, CancellableK b) =>+    a ->                                    -- _obj+    [GLib.IOCondition] ->                   -- condition+    Maybe (b) ->                            -- cancellable+    m ()+socketConditionWait _obj condition cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let condition' = gflagsToWord condition+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_socket_condition_wait _obj' condition' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method Socket::connect+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "address", argType = TInterface "Gio" "SocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "address", argType = TInterface "Gio" "SocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_connect" g_socket_connect :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    Ptr SocketAddress ->                    -- address : TInterface "Gio" "SocketAddress"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++socketConnect ::+    (MonadIO m, SocketK a, SocketAddressK b, CancellableK c) =>+    a ->                                    -- _obj+    b ->                                    -- address+    Maybe (c) ->                            -- cancellable+    m ()+socketConnect _obj address cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let address' = unsafeManagedPtrCastPtr address+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_socket_connect _obj' address' maybeCancellable+        touchManagedPtr _obj+        touchManagedPtr address+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method Socket::connection_factory_create_connection+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SocketConnection"+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_connection_factory_create_connection" g_socket_connection_factory_create_connection :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    IO (Ptr SocketConnection)+++socketConnectionFactoryCreateConnection ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    m SocketConnection+socketConnectionFactoryCreateConnection _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_connection_factory_create_connection _obj'+    checkUnexpectedReturnNULL "g_socket_connection_factory_create_connection" result+    result' <- (wrapObject SocketConnection) result+    touchManagedPtr _obj+    return result'++-- method Socket::get_available_bytes+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_get_available_bytes" g_socket_get_available_bytes :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    IO Int64+++socketGetAvailableBytes ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    m Int64+socketGetAvailableBytes _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_get_available_bytes _obj'+    touchManagedPtr _obj+    return result++-- method Socket::get_blocking+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_get_blocking" g_socket_get_blocking :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    IO CInt+++socketGetBlocking ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    m Bool+socketGetBlocking _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_get_blocking _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Socket::get_broadcast+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_get_broadcast" g_socket_get_broadcast :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    IO CInt+++socketGetBroadcast ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    m Bool+socketGetBroadcast _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_get_broadcast _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Socket::get_credentials+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Credentials"+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_get_credentials" g_socket_get_credentials :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Credentials)+++socketGetCredentials ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    m Credentials+socketGetCredentials _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    onException (do+        result <- propagateGError $ g_socket_get_credentials _obj'+        checkUnexpectedReturnNULL "g_socket_get_credentials" result+        result' <- (wrapObject Credentials) result+        touchManagedPtr _obj+        return result'+     ) (do+        return ()+     )++-- method Socket::get_family+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SocketFamily"+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_get_family" g_socket_get_family :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    IO CUInt+++socketGetFamily ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    m SocketFamily+socketGetFamily _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_get_family _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method Socket::get_fd+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_get_fd" g_socket_get_fd :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    IO Int32+++socketGetFd ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    m Int32+socketGetFd _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_get_fd _obj'+    touchManagedPtr _obj+    return result++-- method Socket::get_keepalive+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_get_keepalive" g_socket_get_keepalive :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    IO CInt+++socketGetKeepalive ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    m Bool+socketGetKeepalive _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_get_keepalive _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Socket::get_listen_backlog+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_get_listen_backlog" g_socket_get_listen_backlog :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    IO Int32+++socketGetListenBacklog ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    m Int32+socketGetListenBacklog _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_get_listen_backlog _obj'+    touchManagedPtr _obj+    return result++-- method Socket::get_local_address+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SocketAddress"+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_get_local_address" g_socket_get_local_address :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr SocketAddress)+++socketGetLocalAddress ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    m SocketAddress+socketGetLocalAddress _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    onException (do+        result <- propagateGError $ g_socket_get_local_address _obj'+        checkUnexpectedReturnNULL "g_socket_get_local_address" result+        result' <- (wrapObject SocketAddress) result+        touchManagedPtr _obj+        return result'+     ) (do+        return ()+     )++-- method Socket::get_multicast_loopback+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_get_multicast_loopback" g_socket_get_multicast_loopback :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    IO CInt+++socketGetMulticastLoopback ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    m Bool+socketGetMulticastLoopback _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_get_multicast_loopback _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Socket::get_multicast_ttl+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_get_multicast_ttl" g_socket_get_multicast_ttl :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    IO Word32+++socketGetMulticastTtl ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    m Word32+socketGetMulticastTtl _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_get_multicast_ttl _obj'+    touchManagedPtr _obj+    return result++-- method Socket::get_option+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "level", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "optname", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "level", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "optname", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_get_option" g_socket_get_option :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    Int32 ->                                -- level : TBasicType TInt32+    Int32 ->                                -- optname : TBasicType TInt32+    Ptr Int32 ->                            -- value : TBasicType TInt32+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++socketGetOption ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- level+    Int32 ->                                -- optname+    m (Int32)+socketGetOption _obj level optname = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    value <- allocMem :: IO (Ptr Int32)+    onException (do+        _ <- propagateGError $ g_socket_get_option _obj' level optname value+        value' <- peek value+        touchManagedPtr _obj+        freeMem value+        return value'+     ) (do+        freeMem value+     )++-- method Socket::get_protocol+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SocketProtocol"+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_get_protocol" g_socket_get_protocol :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    IO CUInt+++socketGetProtocol ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    m SocketProtocol+socketGetProtocol _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_get_protocol _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method Socket::get_remote_address+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SocketAddress"+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_get_remote_address" g_socket_get_remote_address :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr SocketAddress)+++socketGetRemoteAddress ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    m SocketAddress+socketGetRemoteAddress _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    onException (do+        result <- propagateGError $ g_socket_get_remote_address _obj'+        checkUnexpectedReturnNULL "g_socket_get_remote_address" result+        result' <- (wrapObject SocketAddress) result+        touchManagedPtr _obj+        return result'+     ) (do+        return ()+     )++-- method Socket::get_socket_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SocketType"+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_get_socket_type" g_socket_get_socket_type :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    IO CUInt+++socketGetSocketType ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    m SocketType+socketGetSocketType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_get_socket_type _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method Socket::get_timeout+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_get_timeout" g_socket_get_timeout :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    IO Word32+++socketGetTimeout ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    m Word32+socketGetTimeout _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_get_timeout _obj'+    touchManagedPtr _obj+    return result++-- method Socket::get_ttl+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_get_ttl" g_socket_get_ttl :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    IO Word32+++socketGetTtl ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    m Word32+socketGetTtl _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_get_ttl _obj'+    touchManagedPtr _obj+    return result++-- method Socket::is_closed+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_is_closed" g_socket_is_closed :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    IO CInt+++socketIsClosed ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    m Bool+socketIsClosed _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_is_closed _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Socket::is_connected+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_is_connected" g_socket_is_connected :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    IO CInt+++socketIsConnected ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    m Bool+socketIsConnected _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_is_connected _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Socket::join_multicast_group+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "group", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source_specific", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iface", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "group", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source_specific", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iface", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_join_multicast_group" g_socket_join_multicast_group :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    Ptr InetAddress ->                      -- group : TInterface "Gio" "InetAddress"+    CInt ->                                 -- source_specific : TBasicType TBoolean+    CString ->                              -- iface : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++socketJoinMulticastGroup ::+    (MonadIO m, SocketK a, InetAddressK b) =>+    a ->                                    -- _obj+    b ->                                    -- group+    Bool ->                                 -- source_specific+    Maybe (T.Text) ->                       -- iface+    m ()+socketJoinMulticastGroup _obj group source_specific iface = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let group' = unsafeManagedPtrCastPtr group+    let source_specific' = (fromIntegral . fromEnum) source_specific+    maybeIface <- case iface of+        Nothing -> return nullPtr+        Just jIface -> do+            jIface' <- textToCString jIface+            return jIface'+    onException (do+        _ <- propagateGError $ g_socket_join_multicast_group _obj' group' source_specific' maybeIface+        touchManagedPtr _obj+        touchManagedPtr group+        freeMem maybeIface+        return ()+     ) (do+        freeMem maybeIface+     )++-- method Socket::leave_multicast_group+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "group", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source_specific", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iface", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "group", argType = TInterface "Gio" "InetAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source_specific", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iface", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_leave_multicast_group" g_socket_leave_multicast_group :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    Ptr InetAddress ->                      -- group : TInterface "Gio" "InetAddress"+    CInt ->                                 -- source_specific : TBasicType TBoolean+    CString ->                              -- iface : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++socketLeaveMulticastGroup ::+    (MonadIO m, SocketK a, InetAddressK b) =>+    a ->                                    -- _obj+    b ->                                    -- group+    Bool ->                                 -- source_specific+    Maybe (T.Text) ->                       -- iface+    m ()+socketLeaveMulticastGroup _obj group source_specific iface = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let group' = unsafeManagedPtrCastPtr group+    let source_specific' = (fromIntegral . fromEnum) source_specific+    maybeIface <- case iface of+        Nothing -> return nullPtr+        Just jIface -> do+            jIface' <- textToCString jIface+            return jIface'+    onException (do+        _ <- propagateGError $ g_socket_leave_multicast_group _obj' group' source_specific' maybeIface+        touchManagedPtr _obj+        touchManagedPtr group+        freeMem maybeIface+        return ()+     ) (do+        freeMem maybeIface+     )++-- method Socket::listen+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_listen" g_socket_listen :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++socketListen ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    m ()+socketListen _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    onException (do+        _ <- propagateGError $ g_socket_listen _obj'+        touchManagedPtr _obj+        return ()+     ) (do+        return ()+     )++-- method Socket::receive+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_receive" g_socket_receive :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    Ptr Word8 ->                            -- buffer : TCArray False (-1) 2 (TBasicType TUInt8)+    Word64 ->                               -- size : TBasicType TUInt64+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO Int64+++socketReceive ::+    (MonadIO m, SocketK a, CancellableK b) =>+    a ->                                    -- _obj+    ByteString ->                           -- buffer+    Maybe (b) ->                            -- cancellable+    m Int64+socketReceive _obj buffer cancellable = liftIO $ do+    let size = fromIntegral $ B.length buffer+    let _obj' = unsafeManagedPtrCastPtr _obj+    buffer' <- packByteString buffer+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_socket_receive _obj' buffer' size maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem buffer'+        return result+     ) (do+        freeMem buffer'+     )++-- method Socket::receive_from+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "address", argType = TInterface "Gio" "SocketAddress", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "buffer", argType = TCArray False (-1) 3 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 3 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_receive_from" g_socket_receive_from :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    Ptr (Ptr SocketAddress) ->              -- address : TInterface "Gio" "SocketAddress"+    Ptr Word8 ->                            -- buffer : TCArray False (-1) 3 (TBasicType TUInt8)+    Word64 ->                               -- size : TBasicType TUInt64+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO Int64+++socketReceiveFrom ::+    (MonadIO m, SocketK a, CancellableK b) =>+    a ->                                    -- _obj+    ByteString ->                           -- buffer+    Maybe (b) ->                            -- cancellable+    m (Int64,SocketAddress)+socketReceiveFrom _obj buffer cancellable = liftIO $ do+    let size = fromIntegral $ B.length buffer+    let _obj' = unsafeManagedPtrCastPtr _obj+    address <- allocMem :: IO (Ptr (Ptr SocketAddress))+    buffer' <- packByteString buffer+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_socket_receive_from _obj' address buffer' size maybeCancellable+        address' <- peek address+        address'' <- (wrapObject SocketAddress) address'+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem address+        freeMem buffer'+        return (result, address'')+     ) (do+        freeMem address+        freeMem buffer'+     )++-- method Socket::receive_message+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "address", argType = TInterface "Gio" "SocketAddress", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "vectors", argType = TCArray False (-1) 3 (TInterface "Gio" "InputVector"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "num_vectors", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "messages", argType = TCArray False (-1) 5 (TInterface "Gio" "SocketControlMessage"), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "num_messages", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "num_messages", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "num_vectors", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "vectors", argType = TCArray False (-1) 3 (TInterface "Gio" "InputVector"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "messages", argType = TCArray False (-1) 5 (TInterface "Gio" "SocketControlMessage"), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_receive_message" g_socket_receive_message :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    Ptr (Ptr SocketAddress) ->              -- address : TInterface "Gio" "SocketAddress"+    Ptr InputVector ->                      -- vectors : TCArray False (-1) 3 (TInterface "Gio" "InputVector")+    Int32 ->                                -- num_vectors : TBasicType TInt32+    Ptr (Ptr SocketControlMessage) ->       -- messages : TCArray False (-1) 5 (TInterface "Gio" "SocketControlMessage")+    Int32 ->                                -- num_messages : TBasicType TInt32+    Int32 ->                                -- flags : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO Int64+++socketReceiveMessage ::+    (MonadIO m, SocketK a, CancellableK b) =>+    a ->                                    -- _obj+    [InputVector] ->                        -- vectors+    Maybe ([SocketControlMessage]) ->       -- messages+    Int32 ->                                -- flags+    Maybe (b) ->                            -- cancellable+    m (Int64,SocketAddress)+socketReceiveMessage _obj vectors messages flags cancellable = liftIO $ do+    let num_messages = case messages of+            Nothing -> 0+            Just jMessages -> fromIntegral $ length jMessages+    let num_vectors = fromIntegral $ length vectors+    let _obj' = unsafeManagedPtrCastPtr _obj+    address <- allocMem :: IO (Ptr (Ptr SocketAddress))+    let vectors' = map unsafeManagedPtrGetPtr vectors+    vectors'' <- packBlockArray 16 vectors'+    maybeMessages <- case messages of+        Nothing -> return nullPtr+        Just jMessages -> do+            let jMessages' = map unsafeManagedPtrCastPtr jMessages+            jMessages'' <- packPtrArray jMessages'+            return jMessages''+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_socket_receive_message _obj' address vectors'' num_vectors maybeMessages num_messages flags maybeCancellable+        address' <- peek address+        address'' <- (wrapObject SocketAddress) address'+        touchManagedPtr _obj+        mapM_ touchManagedPtr vectors+        whenJust messages (mapM_ touchManagedPtr)+        whenJust cancellable touchManagedPtr+        freeMem address+        freeMem vectors''+        freeMem maybeMessages+        return (result, address'')+     ) (do+        freeMem address+        freeMem vectors''+        freeMem maybeMessages+     )++-- method Socket::receive_with_blocking+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "blocking", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "blocking", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_receive_with_blocking" g_socket_receive_with_blocking :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    Ptr Word8 ->                            -- buffer : TCArray False (-1) 2 (TBasicType TUInt8)+    Word64 ->                               -- size : TBasicType TUInt64+    CInt ->                                 -- blocking : TBasicType TBoolean+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO Int64+++socketReceiveWithBlocking ::+    (MonadIO m, SocketK a, CancellableK b) =>+    a ->                                    -- _obj+    ByteString ->                           -- buffer+    Bool ->                                 -- blocking+    Maybe (b) ->                            -- cancellable+    m Int64+socketReceiveWithBlocking _obj buffer blocking cancellable = liftIO $ do+    let size = fromIntegral $ B.length buffer+    let _obj' = unsafeManagedPtrCastPtr _obj+    buffer' <- packByteString buffer+    let blocking' = (fromIntegral . fromEnum) blocking+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_socket_receive_with_blocking _obj' buffer' size blocking' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem buffer'+        return result+     ) (do+        freeMem buffer'+     )++-- method Socket::send+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_send" g_socket_send :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    Ptr Word8 ->                            -- buffer : TCArray False (-1) 2 (TBasicType TUInt8)+    Word64 ->                               -- size : TBasicType TUInt64+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO Int64+++socketSend ::+    (MonadIO m, SocketK a, CancellableK b) =>+    a ->                                    -- _obj+    ByteString ->                           -- buffer+    Maybe (b) ->                            -- cancellable+    m Int64+socketSend _obj buffer cancellable = liftIO $ do+    let size = fromIntegral $ B.length buffer+    let _obj' = unsafeManagedPtrCastPtr _obj+    buffer' <- packByteString buffer+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_socket_send _obj' buffer' size maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem buffer'+        return result+     ) (do+        freeMem buffer'+     )++-- method Socket::send_message+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "address", argType = TInterface "Gio" "SocketAddress", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "vectors", argType = TCArray False (-1) 3 (TInterface "Gio" "OutputVector"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "num_vectors", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "messages", argType = TCArray False (-1) 5 (TInterface "Gio" "SocketControlMessage"), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "num_messages", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "num_messages", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "num_vectors", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "address", argType = TInterface "Gio" "SocketAddress", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "vectors", argType = TCArray False (-1) 3 (TInterface "Gio" "OutputVector"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "messages", argType = TCArray False (-1) 5 (TInterface "Gio" "SocketControlMessage"), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_send_message" g_socket_send_message :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    Ptr SocketAddress ->                    -- address : TInterface "Gio" "SocketAddress"+    Ptr OutputVector ->                     -- vectors : TCArray False (-1) 3 (TInterface "Gio" "OutputVector")+    Int32 ->                                -- num_vectors : TBasicType TInt32+    Ptr (Ptr SocketControlMessage) ->       -- messages : TCArray False (-1) 5 (TInterface "Gio" "SocketControlMessage")+    Int32 ->                                -- num_messages : TBasicType TInt32+    Int32 ->                                -- flags : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO Int64+++socketSendMessage ::+    (MonadIO m, SocketK a, SocketAddressK b, CancellableK c) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- address+    [OutputVector] ->                       -- vectors+    Maybe ([SocketControlMessage]) ->       -- messages+    Int32 ->                                -- flags+    Maybe (c) ->                            -- cancellable+    m Int64+socketSendMessage _obj address vectors messages flags cancellable = liftIO $ do+    let num_messages = case messages of+            Nothing -> 0+            Just jMessages -> fromIntegral $ length jMessages+    let num_vectors = fromIntegral $ length vectors+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeAddress <- case address of+        Nothing -> return nullPtr+        Just jAddress -> do+            let jAddress' = unsafeManagedPtrCastPtr jAddress+            return jAddress'+    let vectors' = map unsafeManagedPtrGetPtr vectors+    vectors'' <- packBlockArray 16 vectors'+    maybeMessages <- case messages of+        Nothing -> return nullPtr+        Just jMessages -> do+            let jMessages' = map unsafeManagedPtrCastPtr jMessages+            jMessages'' <- packPtrArray jMessages'+            return jMessages''+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_socket_send_message _obj' maybeAddress vectors'' num_vectors maybeMessages num_messages flags maybeCancellable+        touchManagedPtr _obj+        whenJust address touchManagedPtr+        mapM_ touchManagedPtr vectors+        whenJust messages (mapM_ touchManagedPtr)+        whenJust cancellable touchManagedPtr+        freeMem vectors''+        freeMem maybeMessages+        return result+     ) (do+        freeMem vectors''+        freeMem maybeMessages+     )++-- method Socket::send_messages+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "messages", argType = TCArray False (-1) 2 (TInterface "Gio" "OutputMessage"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "num_messages", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "num_messages", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "messages", argType = TCArray False (-1) 2 (TInterface "Gio" "OutputMessage"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_send_messages" g_socket_send_messages :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    Ptr OutputMessage ->                    -- messages : TCArray False (-1) 2 (TInterface "Gio" "OutputMessage")+    Word32 ->                               -- num_messages : TBasicType TUInt32+    Int32 ->                                -- flags : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO Int32+++socketSendMessages ::+    (MonadIO m, SocketK a, CancellableK b) =>+    a ->                                    -- _obj+    [OutputMessage] ->                      -- messages+    Int32 ->                                -- flags+    Maybe (b) ->                            -- cancellable+    m Int32+socketSendMessages _obj messages flags cancellable = liftIO $ do+    let num_messages = fromIntegral $ length messages+    let _obj' = unsafeManagedPtrCastPtr _obj+    let messages' = map unsafeManagedPtrGetPtr messages+    messages'' <- packBlockArray 40 messages'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_socket_send_messages _obj' messages'' num_messages flags maybeCancellable+        touchManagedPtr _obj+        mapM_ touchManagedPtr messages+        whenJust cancellable touchManagedPtr+        freeMem messages''+        return result+     ) (do+        freeMem messages''+     )++-- method Socket::send_to+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "address", argType = TInterface "Gio" "SocketAddress", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 3 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "address", argType = TInterface "Gio" "SocketAddress", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 3 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_send_to" g_socket_send_to :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    Ptr SocketAddress ->                    -- address : TInterface "Gio" "SocketAddress"+    Ptr Word8 ->                            -- buffer : TCArray False (-1) 3 (TBasicType TUInt8)+    Word64 ->                               -- size : TBasicType TUInt64+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO Int64+++socketSendTo ::+    (MonadIO m, SocketK a, SocketAddressK b, CancellableK c) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- address+    ByteString ->                           -- buffer+    Maybe (c) ->                            -- cancellable+    m Int64+socketSendTo _obj address buffer cancellable = liftIO $ do+    let size = fromIntegral $ B.length buffer+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeAddress <- case address of+        Nothing -> return nullPtr+        Just jAddress -> do+            let jAddress' = unsafeManagedPtrCastPtr jAddress+            return jAddress'+    buffer' <- packByteString buffer+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_socket_send_to _obj' maybeAddress buffer' size maybeCancellable+        touchManagedPtr _obj+        whenJust address touchManagedPtr+        whenJust cancellable touchManagedPtr+        freeMem buffer'+        return result+     ) (do+        freeMem buffer'+     )++-- method Socket::send_with_blocking+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "blocking", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "blocking", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_send_with_blocking" g_socket_send_with_blocking :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    Ptr Word8 ->                            -- buffer : TCArray False (-1) 2 (TBasicType TUInt8)+    Word64 ->                               -- size : TBasicType TUInt64+    CInt ->                                 -- blocking : TBasicType TBoolean+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO Int64+++socketSendWithBlocking ::+    (MonadIO m, SocketK a, CancellableK b) =>+    a ->                                    -- _obj+    ByteString ->                           -- buffer+    Bool ->                                 -- blocking+    Maybe (b) ->                            -- cancellable+    m Int64+socketSendWithBlocking _obj buffer blocking cancellable = liftIO $ do+    let size = fromIntegral $ B.length buffer+    let _obj' = unsafeManagedPtrCastPtr _obj+    buffer' <- packByteString buffer+    let blocking' = (fromIntegral . fromEnum) blocking+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_socket_send_with_blocking _obj' buffer' size blocking' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem buffer'+        return result+     ) (do+        freeMem buffer'+     )++-- method Socket::set_blocking+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "blocking", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "blocking", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_set_blocking" g_socket_set_blocking :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    CInt ->                                 -- blocking : TBasicType TBoolean+    IO ()+++socketSetBlocking ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- blocking+    m ()+socketSetBlocking _obj blocking = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let blocking' = (fromIntegral . fromEnum) blocking+    g_socket_set_blocking _obj' blocking'+    touchManagedPtr _obj+    return ()++-- method Socket::set_broadcast+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "broadcast", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "broadcast", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_set_broadcast" g_socket_set_broadcast :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    CInt ->                                 -- broadcast : TBasicType TBoolean+    IO ()+++socketSetBroadcast ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- broadcast+    m ()+socketSetBroadcast _obj broadcast = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let broadcast' = (fromIntegral . fromEnum) broadcast+    g_socket_set_broadcast _obj' broadcast'+    touchManagedPtr _obj+    return ()++-- method Socket::set_keepalive+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "keepalive", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "keepalive", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_set_keepalive" g_socket_set_keepalive :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    CInt ->                                 -- keepalive : TBasicType TBoolean+    IO ()+++socketSetKeepalive ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- keepalive+    m ()+socketSetKeepalive _obj keepalive = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let keepalive' = (fromIntegral . fromEnum) keepalive+    g_socket_set_keepalive _obj' keepalive'+    touchManagedPtr _obj+    return ()++-- method Socket::set_listen_backlog+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "backlog", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "backlog", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_set_listen_backlog" g_socket_set_listen_backlog :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    Int32 ->                                -- backlog : TBasicType TInt32+    IO ()+++socketSetListenBacklog ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- backlog+    m ()+socketSetListenBacklog _obj backlog = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_socket_set_listen_backlog _obj' backlog+    touchManagedPtr _obj+    return ()++-- method Socket::set_multicast_loopback+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "loopback", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "loopback", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_set_multicast_loopback" g_socket_set_multicast_loopback :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    CInt ->                                 -- loopback : TBasicType TBoolean+    IO ()+++socketSetMulticastLoopback ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- loopback+    m ()+socketSetMulticastLoopback _obj loopback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let loopback' = (fromIntegral . fromEnum) loopback+    g_socket_set_multicast_loopback _obj' loopback'+    touchManagedPtr _obj+    return ()++-- method Socket::set_multicast_ttl+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "ttl", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "ttl", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_set_multicast_ttl" g_socket_set_multicast_ttl :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    Word32 ->                               -- ttl : TBasicType TUInt32+    IO ()+++socketSetMulticastTtl ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- ttl+    m ()+socketSetMulticastTtl _obj ttl = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_socket_set_multicast_ttl _obj' ttl+    touchManagedPtr _obj+    return ()++-- method Socket::set_option+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "level", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "optname", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "level", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "optname", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_set_option" g_socket_set_option :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    Int32 ->                                -- level : TBasicType TInt32+    Int32 ->                                -- optname : TBasicType TInt32+    Int32 ->                                -- value : TBasicType TInt32+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++socketSetOption ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- level+    Int32 ->                                -- optname+    Int32 ->                                -- value+    m ()+socketSetOption _obj level optname value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    onException (do+        _ <- propagateGError $ g_socket_set_option _obj' level optname value+        touchManagedPtr _obj+        return ()+     ) (do+        return ()+     )++-- method Socket::set_timeout+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "timeout", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "timeout", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_set_timeout" g_socket_set_timeout :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    Word32 ->                               -- timeout : TBasicType TUInt32+    IO ()+++socketSetTimeout ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- timeout+    m ()+socketSetTimeout _obj timeout = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_socket_set_timeout _obj' timeout+    touchManagedPtr _obj+    return ()++-- method Socket::set_ttl+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "ttl", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "ttl", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_set_ttl" g_socket_set_ttl :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    Word32 ->                               -- ttl : TBasicType TUInt32+    IO ()+++socketSetTtl ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- ttl+    m ()+socketSetTtl _obj ttl = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_socket_set_ttl _obj' ttl+    touchManagedPtr _obj+    return ()++-- method Socket::shutdown+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shutdown_read", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shutdown_write", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shutdown_read", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shutdown_write", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_shutdown" g_socket_shutdown :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    CInt ->                                 -- shutdown_read : TBasicType TBoolean+    CInt ->                                 -- shutdown_write : TBasicType TBoolean+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++socketShutdown ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- shutdown_read+    Bool ->                                 -- shutdown_write+    m ()+socketShutdown _obj shutdown_read shutdown_write = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let shutdown_read' = (fromIntegral . fromEnum) shutdown_read+    let shutdown_write' = (fromIntegral . fromEnum) shutdown_write+    onException (do+        _ <- propagateGError $ g_socket_shutdown _obj' shutdown_read' shutdown_write'+        touchManagedPtr _obj+        return ()+     ) (do+        return ()+     )++-- method Socket::speaks_ipv4+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_speaks_ipv4" g_socket_speaks_ipv4 :: +    Ptr Socket ->                           -- _obj : TInterface "Gio" "Socket"+    IO CInt+++socketSpeaksIpv4 ::+    (MonadIO m, SocketK a) =>+    a ->                                    -- _obj+    m Bool+socketSpeaksIpv4 _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_speaks_ipv4 _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++
+ GI/Gio/Objects/Socket.hs-boot view
@@ -0,0 +1,27 @@+module GI.Gio.Objects.Socket where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Socket = Socket (ForeignPtr Socket)+instance GObject Socket where+class GObject o => SocketK o+instance (GObject o, IsDescendantOf Socket o) => SocketK o+data SocketBlockingPropertyInfo+data SocketBroadcastPropertyInfo+data SocketFamilyPropertyInfo+data SocketFdPropertyInfo+data SocketKeepalivePropertyInfo+data SocketListenBacklogPropertyInfo+data SocketLocalAddressPropertyInfo+data SocketMulticastLoopbackPropertyInfo+data SocketMulticastTtlPropertyInfo+data SocketProtocolPropertyInfo+data SocketRemoteAddressPropertyInfo+data SocketTimeoutPropertyInfo+data SocketTtlPropertyInfo+data SocketTypePropertyInfo
+ GI/Gio/Objects/SocketAddress.hs view
@@ -0,0 +1,211 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.SocketAddress+    ( ++-- * Exported types+    SocketAddress(..)                       ,+    SocketAddressK                          ,+    toSocketAddress                         ,+    noSocketAddress                         ,+++ -- * Methods+-- ** socketAddressGetFamily+    socketAddressGetFamily                  ,+++-- ** socketAddressGetNativeSize+    socketAddressGetNativeSize              ,+++-- ** socketAddressNewFromNative+    socketAddressNewFromNative              ,+++-- ** socketAddressToNative+    socketAddressToNative                   ,+++++ -- * Properties+-- ** Family+    SocketAddressFamilyPropertyInfo         ,+    getSocketAddressFamily                  ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype SocketAddress = SocketAddress (ForeignPtr SocketAddress)+foreign import ccall "g_socket_address_get_type"+    c_g_socket_address_get_type :: IO GType++type instance ParentTypes SocketAddress = SocketAddressParentTypes+type SocketAddressParentTypes = '[GObject.Object, SocketConnectable]++instance GObject SocketAddress where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_socket_address_get_type+    ++class GObject o => SocketAddressK o+instance (GObject o, IsDescendantOf SocketAddress o) => SocketAddressK o++toSocketAddress :: SocketAddressK o => o -> IO SocketAddress+toSocketAddress = unsafeCastTo SocketAddress++noSocketAddress :: Maybe SocketAddress+noSocketAddress = Nothing++-- VVV Prop "family"+   -- Type: TInterface "Gio" "SocketFamily"+   -- Flags: [PropertyReadable]++getSocketAddressFamily :: (MonadIO m, SocketAddressK o) => o -> m SocketFamily+getSocketAddressFamily obj = liftIO $ getObjectPropertyEnum obj "family"++data SocketAddressFamilyPropertyInfo+instance AttrInfo SocketAddressFamilyPropertyInfo where+    type AttrAllowedOps SocketAddressFamilyPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint SocketAddressFamilyPropertyInfo = (~) ()+    type AttrBaseTypeConstraint SocketAddressFamilyPropertyInfo = SocketAddressK+    type AttrGetType SocketAddressFamilyPropertyInfo = SocketFamily+    type AttrLabel SocketAddressFamilyPropertyInfo = "SocketAddress::family"+    attrGet _ = getSocketAddressFamily+    attrSet _ = undefined+    attrConstruct _ = undefined++type instance AttributeList SocketAddress = SocketAddressAttributeList+type SocketAddressAttributeList = ('[ '("family", SocketAddressFamilyPropertyInfo)] :: [(Symbol, *)])++type instance SignalList SocketAddress = SocketAddressSignalList+type SocketAddressSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method SocketAddress::new_from_native+-- method type : Constructor+-- Args : [Arg {argName = "native", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "len", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "native", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "len", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SocketAddress"+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_address_new_from_native" g_socket_address_new_from_native :: +    Ptr () ->                               -- native : TBasicType TVoid+    Word64 ->                               -- len : TBasicType TUInt64+    IO (Ptr SocketAddress)+++socketAddressNewFromNative ::+    (MonadIO m) =>+    Ptr () ->                               -- native+    Word64 ->                               -- len+    m SocketAddress+socketAddressNewFromNative native len = liftIO $ do+    result <- g_socket_address_new_from_native native len+    checkUnexpectedReturnNULL "g_socket_address_new_from_native" result+    result' <- (wrapObject SocketAddress) result+    return result'++-- method SocketAddress::get_family+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SocketFamily"+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_address_get_family" g_socket_address_get_family :: +    Ptr SocketAddress ->                    -- _obj : TInterface "Gio" "SocketAddress"+    IO CUInt+++socketAddressGetFamily ::+    (MonadIO m, SocketAddressK a) =>+    a ->                                    -- _obj+    m SocketFamily+socketAddressGetFamily _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_address_get_family _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method SocketAddress::get_native_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_address_get_native_size" g_socket_address_get_native_size :: +    Ptr SocketAddress ->                    -- _obj : TInterface "Gio" "SocketAddress"+    IO Int64+++socketAddressGetNativeSize ::+    (MonadIO m, SocketAddressK a) =>+    a ->                                    -- _obj+    m Int64+socketAddressGetNativeSize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_address_get_native_size _obj'+    touchManagedPtr _obj+    return result++-- method SocketAddress::to_native+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "dest", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "destlen", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "dest", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "destlen", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_address_to_native" g_socket_address_to_native :: +    Ptr SocketAddress ->                    -- _obj : TInterface "Gio" "SocketAddress"+    Ptr () ->                               -- dest : TBasicType TVoid+    Word64 ->                               -- destlen : TBasicType TUInt64+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++socketAddressToNative ::+    (MonadIO m, SocketAddressK a) =>+    a ->                                    -- _obj+    Ptr () ->                               -- dest+    Word64 ->                               -- destlen+    m ()+socketAddressToNative _obj dest destlen = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    onException (do+        _ <- propagateGError $ g_socket_address_to_native _obj' dest destlen+        touchManagedPtr _obj+        return ()+     ) (do+        return ()+     )++
+ GI/Gio/Objects/SocketAddress.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gio.Objects.SocketAddress where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype SocketAddress = SocketAddress (ForeignPtr SocketAddress)+instance GObject SocketAddress where+class GObject o => SocketAddressK o+instance (GObject o, IsDescendantOf SocketAddress o) => SocketAddressK o+data SocketAddressFamilyPropertyInfo
+ GI/Gio/Objects/SocketAddressEnumerator.hs view
@@ -0,0 +1,190 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.SocketAddressEnumerator+    ( ++-- * Exported types+    SocketAddressEnumerator(..)             ,+    SocketAddressEnumeratorK                ,+    toSocketAddressEnumerator               ,+    noSocketAddressEnumerator               ,+++ -- * Methods+-- ** socketAddressEnumeratorNext+    socketAddressEnumeratorNext             ,+++-- ** socketAddressEnumeratorNextAsync+    socketAddressEnumeratorNextAsync        ,+++-- ** socketAddressEnumeratorNextFinish+    socketAddressEnumeratorNextFinish       ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype SocketAddressEnumerator = SocketAddressEnumerator (ForeignPtr SocketAddressEnumerator)+foreign import ccall "g_socket_address_enumerator_get_type"+    c_g_socket_address_enumerator_get_type :: IO GType++type instance ParentTypes SocketAddressEnumerator = SocketAddressEnumeratorParentTypes+type SocketAddressEnumeratorParentTypes = '[GObject.Object]++instance GObject SocketAddressEnumerator where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_socket_address_enumerator_get_type+    ++class GObject o => SocketAddressEnumeratorK o+instance (GObject o, IsDescendantOf SocketAddressEnumerator o) => SocketAddressEnumeratorK o++toSocketAddressEnumerator :: SocketAddressEnumeratorK o => o -> IO SocketAddressEnumerator+toSocketAddressEnumerator = unsafeCastTo SocketAddressEnumerator++noSocketAddressEnumerator :: Maybe SocketAddressEnumerator+noSocketAddressEnumerator = Nothing++type instance AttributeList SocketAddressEnumerator = SocketAddressEnumeratorAttributeList+type SocketAddressEnumeratorAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList SocketAddressEnumerator = SocketAddressEnumeratorSignalList+type SocketAddressEnumeratorSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method SocketAddressEnumerator::next+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketAddressEnumerator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketAddressEnumerator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SocketAddress"+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_address_enumerator_next" g_socket_address_enumerator_next :: +    Ptr SocketAddressEnumerator ->          -- _obj : TInterface "Gio" "SocketAddressEnumerator"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr SocketAddress)+++socketAddressEnumeratorNext ::+    (MonadIO m, SocketAddressEnumeratorK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m SocketAddress+socketAddressEnumeratorNext _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_socket_address_enumerator_next _obj' maybeCancellable+        checkUnexpectedReturnNULL "g_socket_address_enumerator_next" result+        result' <- (wrapObject SocketAddress) result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )++-- method SocketAddressEnumerator::next_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketAddressEnumerator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketAddressEnumerator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_address_enumerator_next_async" g_socket_address_enumerator_next_async :: +    Ptr SocketAddressEnumerator ->          -- _obj : TInterface "Gio" "SocketAddressEnumerator"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++socketAddressEnumeratorNextAsync ::+    (MonadIO m, SocketAddressEnumeratorK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+socketAddressEnumeratorNextAsync _obj cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_socket_address_enumerator_next_async _obj' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method SocketAddressEnumerator::next_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketAddressEnumerator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketAddressEnumerator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SocketAddress"+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_address_enumerator_next_finish" g_socket_address_enumerator_next_finish :: +    Ptr SocketAddressEnumerator ->          -- _obj : TInterface "Gio" "SocketAddressEnumerator"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr SocketAddress)+++socketAddressEnumeratorNextFinish ::+    (MonadIO m, SocketAddressEnumeratorK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m SocketAddress+socketAddressEnumeratorNextFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        result <- propagateGError $ g_socket_address_enumerator_next_finish _obj' result_'+        checkUnexpectedReturnNULL "g_socket_address_enumerator_next_finish" result+        result' <- (wrapObject SocketAddress) result+        touchManagedPtr _obj+        touchManagedPtr result_+        return result'+     ) (do+        return ()+     )++
+ GI/Gio/Objects/SocketAddressEnumerator.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Objects.SocketAddressEnumerator where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype SocketAddressEnumerator = SocketAddressEnumerator (ForeignPtr SocketAddressEnumerator)+instance GObject SocketAddressEnumerator where+class GObject o => SocketAddressEnumeratorK o+instance (GObject o, IsDescendantOf SocketAddressEnumerator o) => SocketAddressEnumeratorK o
+ GI/Gio/Objects/SocketClient.hs view
@@ -0,0 +1,1591 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.SocketClient+    ( ++-- * Exported types+    SocketClient(..)                        ,+    SocketClientK                           ,+    toSocketClient                          ,+    noSocketClient                          ,+++ -- * Methods+-- ** socketClientAddApplicationProxy+    socketClientAddApplicationProxy         ,+++-- ** socketClientConnect+    socketClientConnect                     ,+++-- ** socketClientConnectAsync+    socketClientConnectAsync                ,+++-- ** socketClientConnectFinish+    socketClientConnectFinish               ,+++-- ** socketClientConnectToHost+    socketClientConnectToHost               ,+++-- ** socketClientConnectToHostAsync+    socketClientConnectToHostAsync          ,+++-- ** socketClientConnectToHostFinish+    socketClientConnectToHostFinish         ,+++-- ** socketClientConnectToService+    socketClientConnectToService            ,+++-- ** socketClientConnectToServiceAsync+    socketClientConnectToServiceAsync       ,+++-- ** socketClientConnectToServiceFinish+    socketClientConnectToServiceFinish      ,+++-- ** socketClientConnectToUri+    socketClientConnectToUri                ,+++-- ** socketClientConnectToUriAsync+    socketClientConnectToUriAsync           ,+++-- ** socketClientConnectToUriFinish+    socketClientConnectToUriFinish          ,+++-- ** socketClientGetEnableProxy+    socketClientGetEnableProxy              ,+++-- ** socketClientGetFamily+    socketClientGetFamily                   ,+++-- ** socketClientGetLocalAddress+    socketClientGetLocalAddress             ,+++-- ** socketClientGetProtocol+    socketClientGetProtocol                 ,+++-- ** socketClientGetProxyResolver+    socketClientGetProxyResolver            ,+++-- ** socketClientGetSocketType+    socketClientGetSocketType               ,+++-- ** socketClientGetTimeout+    socketClientGetTimeout                  ,+++-- ** socketClientGetTls+    socketClientGetTls                      ,+++-- ** socketClientGetTlsValidationFlags+    socketClientGetTlsValidationFlags       ,+++-- ** socketClientNew+    socketClientNew                         ,+++-- ** socketClientSetEnableProxy+    socketClientSetEnableProxy              ,+++-- ** socketClientSetFamily+    socketClientSetFamily                   ,+++-- ** socketClientSetLocalAddress+    socketClientSetLocalAddress             ,+++-- ** socketClientSetProtocol+    socketClientSetProtocol                 ,+++-- ** socketClientSetProxyResolver+    socketClientSetProxyResolver            ,+++-- ** socketClientSetSocketType+    socketClientSetSocketType               ,+++-- ** socketClientSetTimeout+    socketClientSetTimeout                  ,+++-- ** socketClientSetTls+    socketClientSetTls                      ,+++-- ** socketClientSetTlsValidationFlags+    socketClientSetTlsValidationFlags       ,+++++ -- * Properties+-- ** EnableProxy+    SocketClientEnableProxyPropertyInfo     ,+    constructSocketClientEnableProxy        ,+    getSocketClientEnableProxy              ,+    setSocketClientEnableProxy              ,+++-- ** Family+    SocketClientFamilyPropertyInfo          ,+    constructSocketClientFamily             ,+    getSocketClientFamily                   ,+    setSocketClientFamily                   ,+++-- ** LocalAddress+    SocketClientLocalAddressPropertyInfo    ,+    constructSocketClientLocalAddress       ,+    getSocketClientLocalAddress             ,+    setSocketClientLocalAddress             ,+++-- ** Protocol+    SocketClientProtocolPropertyInfo        ,+    constructSocketClientProtocol           ,+    getSocketClientProtocol                 ,+    setSocketClientProtocol                 ,+++-- ** ProxyResolver+    SocketClientProxyResolverPropertyInfo   ,+    constructSocketClientProxyResolver      ,+    getSocketClientProxyResolver            ,+    setSocketClientProxyResolver            ,+++-- ** Timeout+    SocketClientTimeoutPropertyInfo         ,+    constructSocketClientTimeout            ,+    getSocketClientTimeout                  ,+    setSocketClientTimeout                  ,+++-- ** Tls+    SocketClientTlsPropertyInfo             ,+    constructSocketClientTls                ,+    getSocketClientTls                      ,+    setSocketClientTls                      ,+++-- ** TlsValidationFlags+    SocketClientTlsValidationFlagsPropertyInfo,+    constructSocketClientTlsValidationFlags ,+    getSocketClientTlsValidationFlags       ,+    setSocketClientTlsValidationFlags       ,+++-- ** Type+    SocketClientTypePropertyInfo            ,+    constructSocketClientType               ,+    getSocketClientType                     ,+    setSocketClientType                     ,+++++ -- * Signals+-- ** Event+    SocketClientEventCallback               ,+    SocketClientEventCallbackC              ,+    SocketClientEventSignalInfo             ,+    afterSocketClientEvent                  ,+    mkSocketClientEventCallback             ,+    noSocketClientEventCallback             ,+    onSocketClientEvent                     ,+    socketClientEventCallbackWrapper        ,+    socketClientEventClosure                ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype SocketClient = SocketClient (ForeignPtr SocketClient)+foreign import ccall "g_socket_client_get_type"+    c_g_socket_client_get_type :: IO GType++type instance ParentTypes SocketClient = SocketClientParentTypes+type SocketClientParentTypes = '[GObject.Object]++instance GObject SocketClient where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_socket_client_get_type+    ++class GObject o => SocketClientK o+instance (GObject o, IsDescendantOf SocketClient o) => SocketClientK o++toSocketClient :: SocketClientK o => o -> IO SocketClient+toSocketClient = unsafeCastTo SocketClient++noSocketClient :: Maybe SocketClient+noSocketClient = Nothing++-- signal SocketClient::event+type SocketClientEventCallback =+    SocketClientEvent ->+    SocketConnectable ->+    Maybe IOStream ->+    IO ()++noSocketClientEventCallback :: Maybe SocketClientEventCallback+noSocketClientEventCallback = Nothing++type SocketClientEventCallbackC =+    Ptr () ->                               -- object+    CUInt ->+    Ptr SocketConnectable ->+    Ptr IOStream ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkSocketClientEventCallback :: SocketClientEventCallbackC -> IO (FunPtr SocketClientEventCallbackC)++socketClientEventClosure :: SocketClientEventCallback -> IO Closure+socketClientEventClosure cb = newCClosure =<< mkSocketClientEventCallback wrapped+    where wrapped = socketClientEventCallbackWrapper cb++socketClientEventCallbackWrapper ::+    SocketClientEventCallback ->+    Ptr () ->+    CUInt ->+    Ptr SocketConnectable ->+    Ptr IOStream ->+    Ptr () ->+    IO ()+socketClientEventCallbackWrapper _cb _ event connectable connection _ = do+    let event' = (toEnum . fromIntegral) event+    connectable' <- (newObject SocketConnectable) connectable+    maybeConnection <-+        if connection == nullPtr+        then return Nothing+        else do+            connection' <- (newObject IOStream) connection+            return $ Just connection'+    _cb  event' connectable' maybeConnection++onSocketClientEvent :: (GObject a, MonadIO m) => a -> SocketClientEventCallback -> m SignalHandlerId+onSocketClientEvent obj cb = liftIO $ connectSocketClientEvent obj cb SignalConnectBefore+afterSocketClientEvent :: (GObject a, MonadIO m) => a -> SocketClientEventCallback -> m SignalHandlerId+afterSocketClientEvent obj cb = connectSocketClientEvent obj cb SignalConnectAfter++connectSocketClientEvent :: (GObject a, MonadIO m) =>+                            a -> SocketClientEventCallback -> SignalConnectMode -> m SignalHandlerId+connectSocketClientEvent obj cb after = liftIO $ do+    cb' <- mkSocketClientEventCallback (socketClientEventCallbackWrapper cb)+    connectSignalFunPtr obj "event" cb' after++-- VVV Prop "enable-proxy"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getSocketClientEnableProxy :: (MonadIO m, SocketClientK o) => o -> m Bool+getSocketClientEnableProxy obj = liftIO $ getObjectPropertyBool obj "enable-proxy"++setSocketClientEnableProxy :: (MonadIO m, SocketClientK o) => o -> Bool -> m ()+setSocketClientEnableProxy obj val = liftIO $ setObjectPropertyBool obj "enable-proxy" val++constructSocketClientEnableProxy :: Bool -> IO ([Char], GValue)+constructSocketClientEnableProxy val = constructObjectPropertyBool "enable-proxy" val++data SocketClientEnableProxyPropertyInfo+instance AttrInfo SocketClientEnableProxyPropertyInfo where+    type AttrAllowedOps SocketClientEnableProxyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SocketClientEnableProxyPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint SocketClientEnableProxyPropertyInfo = SocketClientK+    type AttrGetType SocketClientEnableProxyPropertyInfo = Bool+    type AttrLabel SocketClientEnableProxyPropertyInfo = "SocketClient::enable-proxy"+    attrGet _ = getSocketClientEnableProxy+    attrSet _ = setSocketClientEnableProxy+    attrConstruct _ = constructSocketClientEnableProxy++-- VVV Prop "family"+   -- Type: TInterface "Gio" "SocketFamily"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getSocketClientFamily :: (MonadIO m, SocketClientK o) => o -> m SocketFamily+getSocketClientFamily obj = liftIO $ getObjectPropertyEnum obj "family"++setSocketClientFamily :: (MonadIO m, SocketClientK o) => o -> SocketFamily -> m ()+setSocketClientFamily obj val = liftIO $ setObjectPropertyEnum obj "family" val++constructSocketClientFamily :: SocketFamily -> IO ([Char], GValue)+constructSocketClientFamily val = constructObjectPropertyEnum "family" val++data SocketClientFamilyPropertyInfo+instance AttrInfo SocketClientFamilyPropertyInfo where+    type AttrAllowedOps SocketClientFamilyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SocketClientFamilyPropertyInfo = (~) SocketFamily+    type AttrBaseTypeConstraint SocketClientFamilyPropertyInfo = SocketClientK+    type AttrGetType SocketClientFamilyPropertyInfo = SocketFamily+    type AttrLabel SocketClientFamilyPropertyInfo = "SocketClient::family"+    attrGet _ = getSocketClientFamily+    attrSet _ = setSocketClientFamily+    attrConstruct _ = constructSocketClientFamily++-- VVV Prop "local-address"+   -- Type: TInterface "Gio" "SocketAddress"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getSocketClientLocalAddress :: (MonadIO m, SocketClientK o) => o -> m SocketAddress+getSocketClientLocalAddress obj = liftIO $ getObjectPropertyObject obj "local-address" SocketAddress++setSocketClientLocalAddress :: (MonadIO m, SocketClientK o, SocketAddressK a) => o -> a -> m ()+setSocketClientLocalAddress obj val = liftIO $ setObjectPropertyObject obj "local-address" val++constructSocketClientLocalAddress :: (SocketAddressK a) => a -> IO ([Char], GValue)+constructSocketClientLocalAddress val = constructObjectPropertyObject "local-address" val++data SocketClientLocalAddressPropertyInfo+instance AttrInfo SocketClientLocalAddressPropertyInfo where+    type AttrAllowedOps SocketClientLocalAddressPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SocketClientLocalAddressPropertyInfo = SocketAddressK+    type AttrBaseTypeConstraint SocketClientLocalAddressPropertyInfo = SocketClientK+    type AttrGetType SocketClientLocalAddressPropertyInfo = SocketAddress+    type AttrLabel SocketClientLocalAddressPropertyInfo = "SocketClient::local-address"+    attrGet _ = getSocketClientLocalAddress+    attrSet _ = setSocketClientLocalAddress+    attrConstruct _ = constructSocketClientLocalAddress++-- VVV Prop "protocol"+   -- Type: TInterface "Gio" "SocketProtocol"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getSocketClientProtocol :: (MonadIO m, SocketClientK o) => o -> m SocketProtocol+getSocketClientProtocol obj = liftIO $ getObjectPropertyEnum obj "protocol"++setSocketClientProtocol :: (MonadIO m, SocketClientK o) => o -> SocketProtocol -> m ()+setSocketClientProtocol obj val = liftIO $ setObjectPropertyEnum obj "protocol" val++constructSocketClientProtocol :: SocketProtocol -> IO ([Char], GValue)+constructSocketClientProtocol val = constructObjectPropertyEnum "protocol" val++data SocketClientProtocolPropertyInfo+instance AttrInfo SocketClientProtocolPropertyInfo where+    type AttrAllowedOps SocketClientProtocolPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SocketClientProtocolPropertyInfo = (~) SocketProtocol+    type AttrBaseTypeConstraint SocketClientProtocolPropertyInfo = SocketClientK+    type AttrGetType SocketClientProtocolPropertyInfo = SocketProtocol+    type AttrLabel SocketClientProtocolPropertyInfo = "SocketClient::protocol"+    attrGet _ = getSocketClientProtocol+    attrSet _ = setSocketClientProtocol+    attrConstruct _ = constructSocketClientProtocol++-- VVV Prop "proxy-resolver"+   -- Type: TInterface "Gio" "ProxyResolver"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getSocketClientProxyResolver :: (MonadIO m, SocketClientK o) => o -> m ProxyResolver+getSocketClientProxyResolver obj = liftIO $ getObjectPropertyObject obj "proxy-resolver" ProxyResolver++setSocketClientProxyResolver :: (MonadIO m, SocketClientK o, ProxyResolverK a) => o -> a -> m ()+setSocketClientProxyResolver obj val = liftIO $ setObjectPropertyObject obj "proxy-resolver" val++constructSocketClientProxyResolver :: (ProxyResolverK a) => a -> IO ([Char], GValue)+constructSocketClientProxyResolver val = constructObjectPropertyObject "proxy-resolver" val++data SocketClientProxyResolverPropertyInfo+instance AttrInfo SocketClientProxyResolverPropertyInfo where+    type AttrAllowedOps SocketClientProxyResolverPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SocketClientProxyResolverPropertyInfo = ProxyResolverK+    type AttrBaseTypeConstraint SocketClientProxyResolverPropertyInfo = SocketClientK+    type AttrGetType SocketClientProxyResolverPropertyInfo = ProxyResolver+    type AttrLabel SocketClientProxyResolverPropertyInfo = "SocketClient::proxy-resolver"+    attrGet _ = getSocketClientProxyResolver+    attrSet _ = setSocketClientProxyResolver+    attrConstruct _ = constructSocketClientProxyResolver++-- VVV Prop "timeout"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getSocketClientTimeout :: (MonadIO m, SocketClientK o) => o -> m Word32+getSocketClientTimeout obj = liftIO $ getObjectPropertyCUInt obj "timeout"++setSocketClientTimeout :: (MonadIO m, SocketClientK o) => o -> Word32 -> m ()+setSocketClientTimeout obj val = liftIO $ setObjectPropertyCUInt obj "timeout" val++constructSocketClientTimeout :: Word32 -> IO ([Char], GValue)+constructSocketClientTimeout val = constructObjectPropertyCUInt "timeout" val++data SocketClientTimeoutPropertyInfo+instance AttrInfo SocketClientTimeoutPropertyInfo where+    type AttrAllowedOps SocketClientTimeoutPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SocketClientTimeoutPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint SocketClientTimeoutPropertyInfo = SocketClientK+    type AttrGetType SocketClientTimeoutPropertyInfo = Word32+    type AttrLabel SocketClientTimeoutPropertyInfo = "SocketClient::timeout"+    attrGet _ = getSocketClientTimeout+    attrSet _ = setSocketClientTimeout+    attrConstruct _ = constructSocketClientTimeout++-- VVV Prop "tls"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getSocketClientTls :: (MonadIO m, SocketClientK o) => o -> m Bool+getSocketClientTls obj = liftIO $ getObjectPropertyBool obj "tls"++setSocketClientTls :: (MonadIO m, SocketClientK o) => o -> Bool -> m ()+setSocketClientTls obj val = liftIO $ setObjectPropertyBool obj "tls" val++constructSocketClientTls :: Bool -> IO ([Char], GValue)+constructSocketClientTls val = constructObjectPropertyBool "tls" val++data SocketClientTlsPropertyInfo+instance AttrInfo SocketClientTlsPropertyInfo where+    type AttrAllowedOps SocketClientTlsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SocketClientTlsPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint SocketClientTlsPropertyInfo = SocketClientK+    type AttrGetType SocketClientTlsPropertyInfo = Bool+    type AttrLabel SocketClientTlsPropertyInfo = "SocketClient::tls"+    attrGet _ = getSocketClientTls+    attrSet _ = setSocketClientTls+    attrConstruct _ = constructSocketClientTls++-- VVV Prop "tls-validation-flags"+   -- Type: TInterface "Gio" "TlsCertificateFlags"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getSocketClientTlsValidationFlags :: (MonadIO m, SocketClientK o) => o -> m [TlsCertificateFlags]+getSocketClientTlsValidationFlags obj = liftIO $ getObjectPropertyFlags obj "tls-validation-flags"++setSocketClientTlsValidationFlags :: (MonadIO m, SocketClientK o) => o -> [TlsCertificateFlags] -> m ()+setSocketClientTlsValidationFlags obj val = liftIO $ setObjectPropertyFlags obj "tls-validation-flags" val++constructSocketClientTlsValidationFlags :: [TlsCertificateFlags] -> IO ([Char], GValue)+constructSocketClientTlsValidationFlags val = constructObjectPropertyFlags "tls-validation-flags" val++data SocketClientTlsValidationFlagsPropertyInfo+instance AttrInfo SocketClientTlsValidationFlagsPropertyInfo where+    type AttrAllowedOps SocketClientTlsValidationFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SocketClientTlsValidationFlagsPropertyInfo = (~) [TlsCertificateFlags]+    type AttrBaseTypeConstraint SocketClientTlsValidationFlagsPropertyInfo = SocketClientK+    type AttrGetType SocketClientTlsValidationFlagsPropertyInfo = [TlsCertificateFlags]+    type AttrLabel SocketClientTlsValidationFlagsPropertyInfo = "SocketClient::tls-validation-flags"+    attrGet _ = getSocketClientTlsValidationFlags+    attrSet _ = setSocketClientTlsValidationFlags+    attrConstruct _ = constructSocketClientTlsValidationFlags++-- VVV Prop "type"+   -- Type: TInterface "Gio" "SocketType"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getSocketClientType :: (MonadIO m, SocketClientK o) => o -> m SocketType+getSocketClientType obj = liftIO $ getObjectPropertyEnum obj "type"++setSocketClientType :: (MonadIO m, SocketClientK o) => o -> SocketType -> m ()+setSocketClientType obj val = liftIO $ setObjectPropertyEnum obj "type" val++constructSocketClientType :: SocketType -> IO ([Char], GValue)+constructSocketClientType val = constructObjectPropertyEnum "type" val++data SocketClientTypePropertyInfo+instance AttrInfo SocketClientTypePropertyInfo where+    type AttrAllowedOps SocketClientTypePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SocketClientTypePropertyInfo = (~) SocketType+    type AttrBaseTypeConstraint SocketClientTypePropertyInfo = SocketClientK+    type AttrGetType SocketClientTypePropertyInfo = SocketType+    type AttrLabel SocketClientTypePropertyInfo = "SocketClient::type"+    attrGet _ = getSocketClientType+    attrSet _ = setSocketClientType+    attrConstruct _ = constructSocketClientType++type instance AttributeList SocketClient = SocketClientAttributeList+type SocketClientAttributeList = ('[ '("enable-proxy", SocketClientEnableProxyPropertyInfo), '("family", SocketClientFamilyPropertyInfo), '("local-address", SocketClientLocalAddressPropertyInfo), '("protocol", SocketClientProtocolPropertyInfo), '("proxy-resolver", SocketClientProxyResolverPropertyInfo), '("timeout", SocketClientTimeoutPropertyInfo), '("tls", SocketClientTlsPropertyInfo), '("tls-validation-flags", SocketClientTlsValidationFlagsPropertyInfo), '("type", SocketClientTypePropertyInfo)] :: [(Symbol, *)])++data SocketClientEventSignalInfo+instance SignalInfo SocketClientEventSignalInfo where+    type HaskellCallbackType SocketClientEventSignalInfo = SocketClientEventCallback+    connectSignal _ = connectSocketClientEvent++type instance SignalList SocketClient = SocketClientSignalList+type SocketClientSignalList = ('[ '("event", SocketClientEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method SocketClient::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gio" "SocketClient"+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_client_new" g_socket_client_new :: +    IO (Ptr SocketClient)+++socketClientNew ::+    (MonadIO m) =>+    m SocketClient+socketClientNew  = liftIO $ do+    result <- g_socket_client_new+    checkUnexpectedReturnNULL "g_socket_client_new" result+    result' <- (wrapObject SocketClient) result+    return result'++-- method SocketClient::add_application_proxy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "protocol", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "protocol", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_client_add_application_proxy" g_socket_client_add_application_proxy :: +    Ptr SocketClient ->                     -- _obj : TInterface "Gio" "SocketClient"+    CString ->                              -- protocol : TBasicType TUTF8+    IO ()+++socketClientAddApplicationProxy ::+    (MonadIO m, SocketClientK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- protocol+    m ()+socketClientAddApplicationProxy _obj protocol = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    protocol' <- textToCString protocol+    g_socket_client_add_application_proxy _obj' protocol'+    touchManagedPtr _obj+    freeMem protocol'+    return ()++-- method SocketClient::connect+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "connectable", argType = TInterface "Gio" "SocketConnectable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "connectable", argType = TInterface "Gio" "SocketConnectable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SocketConnection"+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_client_connect" g_socket_client_connect :: +    Ptr SocketClient ->                     -- _obj : TInterface "Gio" "SocketClient"+    Ptr SocketConnectable ->                -- connectable : TInterface "Gio" "SocketConnectable"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr SocketConnection)+++socketClientConnect ::+    (MonadIO m, SocketClientK a, SocketConnectableK b, CancellableK c) =>+    a ->                                    -- _obj+    b ->                                    -- connectable+    Maybe (c) ->                            -- cancellable+    m SocketConnection+socketClientConnect _obj connectable cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let connectable' = unsafeManagedPtrCastPtr connectable+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_socket_client_connect _obj' connectable' maybeCancellable+        checkUnexpectedReturnNULL "g_socket_client_connect" result+        result' <- (wrapObject SocketConnection) result+        touchManagedPtr _obj+        touchManagedPtr connectable+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )++-- method SocketClient::connect_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "connectable", argType = TInterface "Gio" "SocketConnectable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "connectable", argType = TInterface "Gio" "SocketConnectable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_client_connect_async" g_socket_client_connect_async :: +    Ptr SocketClient ->                     -- _obj : TInterface "Gio" "SocketClient"+    Ptr SocketConnectable ->                -- connectable : TInterface "Gio" "SocketConnectable"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++socketClientConnectAsync ::+    (MonadIO m, SocketClientK a, SocketConnectableK b, CancellableK c) =>+    a ->                                    -- _obj+    b ->                                    -- connectable+    Maybe (c) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+socketClientConnectAsync _obj connectable cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let connectable' = unsafeManagedPtrCastPtr connectable+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_socket_client_connect_async _obj' connectable' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    touchManagedPtr connectable+    whenJust cancellable touchManagedPtr+    return ()++-- method SocketClient::connect_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SocketConnection"+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_client_connect_finish" g_socket_client_connect_finish :: +    Ptr SocketClient ->                     -- _obj : TInterface "Gio" "SocketClient"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr SocketConnection)+++socketClientConnectFinish ::+    (MonadIO m, SocketClientK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m SocketConnection+socketClientConnectFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        result <- propagateGError $ g_socket_client_connect_finish _obj' result_'+        checkUnexpectedReturnNULL "g_socket_client_connect_finish" result+        result' <- (wrapObject SocketConnection) result+        touchManagedPtr _obj+        touchManagedPtr result_+        return result'+     ) (do+        return ()+     )++-- method SocketClient::connect_to_host+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "host_and_port", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "default_port", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "host_and_port", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "default_port", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SocketConnection"+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_client_connect_to_host" g_socket_client_connect_to_host :: +    Ptr SocketClient ->                     -- _obj : TInterface "Gio" "SocketClient"+    CString ->                              -- host_and_port : TBasicType TUTF8+    Word16 ->                               -- default_port : TBasicType TUInt16+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr SocketConnection)+++socketClientConnectToHost ::+    (MonadIO m, SocketClientK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- host_and_port+    Word16 ->                               -- default_port+    Maybe (b) ->                            -- cancellable+    m SocketConnection+socketClientConnectToHost _obj host_and_port default_port cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    host_and_port' <- textToCString host_and_port+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_socket_client_connect_to_host _obj' host_and_port' default_port maybeCancellable+        checkUnexpectedReturnNULL "g_socket_client_connect_to_host" result+        result' <- (wrapObject SocketConnection) result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem host_and_port'+        return result'+     ) (do+        freeMem host_and_port'+     )++-- method SocketClient::connect_to_host_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "host_and_port", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "default_port", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "host_and_port", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "default_port", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_client_connect_to_host_async" g_socket_client_connect_to_host_async :: +    Ptr SocketClient ->                     -- _obj : TInterface "Gio" "SocketClient"+    CString ->                              -- host_and_port : TBasicType TUTF8+    Word16 ->                               -- default_port : TBasicType TUInt16+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++socketClientConnectToHostAsync ::+    (MonadIO m, SocketClientK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- host_and_port+    Word16 ->                               -- default_port+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+socketClientConnectToHostAsync _obj host_and_port default_port cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    host_and_port' <- textToCString host_and_port+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_socket_client_connect_to_host_async _obj' host_and_port' default_port maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    freeMem host_and_port'+    return ()++-- method SocketClient::connect_to_host_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SocketConnection"+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_client_connect_to_host_finish" g_socket_client_connect_to_host_finish :: +    Ptr SocketClient ->                     -- _obj : TInterface "Gio" "SocketClient"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr SocketConnection)+++socketClientConnectToHostFinish ::+    (MonadIO m, SocketClientK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m SocketConnection+socketClientConnectToHostFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        result <- propagateGError $ g_socket_client_connect_to_host_finish _obj' result_'+        checkUnexpectedReturnNULL "g_socket_client_connect_to_host_finish" result+        result' <- (wrapObject SocketConnection) result+        touchManagedPtr _obj+        touchManagedPtr result_+        return result'+     ) (do+        return ()+     )++-- method SocketClient::connect_to_service+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "domain", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "service", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "domain", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "service", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SocketConnection"+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_client_connect_to_service" g_socket_client_connect_to_service :: +    Ptr SocketClient ->                     -- _obj : TInterface "Gio" "SocketClient"+    CString ->                              -- domain : TBasicType TUTF8+    CString ->                              -- service : TBasicType TUTF8+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr SocketConnection)+++socketClientConnectToService ::+    (MonadIO m, SocketClientK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- domain+    T.Text ->                               -- service+    Maybe (b) ->                            -- cancellable+    m SocketConnection+socketClientConnectToService _obj domain service cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    domain' <- textToCString domain+    service' <- textToCString service+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_socket_client_connect_to_service _obj' domain' service' maybeCancellable+        checkUnexpectedReturnNULL "g_socket_client_connect_to_service" result+        result' <- (wrapObject SocketConnection) result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem domain'+        freeMem service'+        return result'+     ) (do+        freeMem domain'+        freeMem service'+     )++-- method SocketClient::connect_to_service_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "domain", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "service", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "domain", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "service", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_client_connect_to_service_async" g_socket_client_connect_to_service_async :: +    Ptr SocketClient ->                     -- _obj : TInterface "Gio" "SocketClient"+    CString ->                              -- domain : TBasicType TUTF8+    CString ->                              -- service : TBasicType TUTF8+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++socketClientConnectToServiceAsync ::+    (MonadIO m, SocketClientK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- domain+    T.Text ->                               -- service+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+socketClientConnectToServiceAsync _obj domain service cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    domain' <- textToCString domain+    service' <- textToCString service+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_socket_client_connect_to_service_async _obj' domain' service' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    freeMem domain'+    freeMem service'+    return ()++-- method SocketClient::connect_to_service_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SocketConnection"+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_client_connect_to_service_finish" g_socket_client_connect_to_service_finish :: +    Ptr SocketClient ->                     -- _obj : TInterface "Gio" "SocketClient"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr SocketConnection)+++socketClientConnectToServiceFinish ::+    (MonadIO m, SocketClientK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m SocketConnection+socketClientConnectToServiceFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        result <- propagateGError $ g_socket_client_connect_to_service_finish _obj' result_'+        checkUnexpectedReturnNULL "g_socket_client_connect_to_service_finish" result+        result' <- (wrapObject SocketConnection) result+        touchManagedPtr _obj+        touchManagedPtr result_+        return result'+     ) (do+        return ()+     )++-- method SocketClient::connect_to_uri+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "default_port", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "default_port", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SocketConnection"+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_client_connect_to_uri" g_socket_client_connect_to_uri :: +    Ptr SocketClient ->                     -- _obj : TInterface "Gio" "SocketClient"+    CString ->                              -- uri : TBasicType TUTF8+    Word16 ->                               -- default_port : TBasicType TUInt16+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr SocketConnection)+++socketClientConnectToUri ::+    (MonadIO m, SocketClientK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- uri+    Word16 ->                               -- default_port+    Maybe (b) ->                            -- cancellable+    m SocketConnection+socketClientConnectToUri _obj uri default_port cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    uri' <- textToCString uri+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_socket_client_connect_to_uri _obj' uri' default_port maybeCancellable+        checkUnexpectedReturnNULL "g_socket_client_connect_to_uri" result+        result' <- (wrapObject SocketConnection) result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem uri'+        return result'+     ) (do+        freeMem uri'+     )++-- method SocketClient::connect_to_uri_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "default_port", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "default_port", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_client_connect_to_uri_async" g_socket_client_connect_to_uri_async :: +    Ptr SocketClient ->                     -- _obj : TInterface "Gio" "SocketClient"+    CString ->                              -- uri : TBasicType TUTF8+    Word16 ->                               -- default_port : TBasicType TUInt16+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++socketClientConnectToUriAsync ::+    (MonadIO m, SocketClientK a, CancellableK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- uri+    Word16 ->                               -- default_port+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+socketClientConnectToUriAsync _obj uri default_port cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    uri' <- textToCString uri+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_socket_client_connect_to_uri_async _obj' uri' default_port maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    freeMem uri'+    return ()++-- method SocketClient::connect_to_uri_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SocketConnection"+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_client_connect_to_uri_finish" g_socket_client_connect_to_uri_finish :: +    Ptr SocketClient ->                     -- _obj : TInterface "Gio" "SocketClient"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr SocketConnection)+++socketClientConnectToUriFinish ::+    (MonadIO m, SocketClientK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m SocketConnection+socketClientConnectToUriFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        result <- propagateGError $ g_socket_client_connect_to_uri_finish _obj' result_'+        checkUnexpectedReturnNULL "g_socket_client_connect_to_uri_finish" result+        result' <- (wrapObject SocketConnection) result+        touchManagedPtr _obj+        touchManagedPtr result_+        return result'+     ) (do+        return ()+     )++-- method SocketClient::get_enable_proxy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_client_get_enable_proxy" g_socket_client_get_enable_proxy :: +    Ptr SocketClient ->                     -- _obj : TInterface "Gio" "SocketClient"+    IO CInt+++socketClientGetEnableProxy ::+    (MonadIO m, SocketClientK a) =>+    a ->                                    -- _obj+    m Bool+socketClientGetEnableProxy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_client_get_enable_proxy _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method SocketClient::get_family+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SocketFamily"+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_client_get_family" g_socket_client_get_family :: +    Ptr SocketClient ->                     -- _obj : TInterface "Gio" "SocketClient"+    IO CUInt+++socketClientGetFamily ::+    (MonadIO m, SocketClientK a) =>+    a ->                                    -- _obj+    m SocketFamily+socketClientGetFamily _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_client_get_family _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method SocketClient::get_local_address+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SocketAddress"+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_client_get_local_address" g_socket_client_get_local_address :: +    Ptr SocketClient ->                     -- _obj : TInterface "Gio" "SocketClient"+    IO (Ptr SocketAddress)+++socketClientGetLocalAddress ::+    (MonadIO m, SocketClientK a) =>+    a ->                                    -- _obj+    m SocketAddress+socketClientGetLocalAddress _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_client_get_local_address _obj'+    checkUnexpectedReturnNULL "g_socket_client_get_local_address" result+    result' <- (newObject SocketAddress) result+    touchManagedPtr _obj+    return result'++-- method SocketClient::get_protocol+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SocketProtocol"+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_client_get_protocol" g_socket_client_get_protocol :: +    Ptr SocketClient ->                     -- _obj : TInterface "Gio" "SocketClient"+    IO CUInt+++socketClientGetProtocol ::+    (MonadIO m, SocketClientK a) =>+    a ->                                    -- _obj+    m SocketProtocol+socketClientGetProtocol _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_client_get_protocol _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method SocketClient::get_proxy_resolver+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "ProxyResolver"+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_client_get_proxy_resolver" g_socket_client_get_proxy_resolver :: +    Ptr SocketClient ->                     -- _obj : TInterface "Gio" "SocketClient"+    IO (Ptr ProxyResolver)+++socketClientGetProxyResolver ::+    (MonadIO m, SocketClientK a) =>+    a ->                                    -- _obj+    m ProxyResolver+socketClientGetProxyResolver _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_client_get_proxy_resolver _obj'+    checkUnexpectedReturnNULL "g_socket_client_get_proxy_resolver" result+    result' <- (newObject ProxyResolver) result+    touchManagedPtr _obj+    return result'++-- method SocketClient::get_socket_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SocketType"+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_client_get_socket_type" g_socket_client_get_socket_type :: +    Ptr SocketClient ->                     -- _obj : TInterface "Gio" "SocketClient"+    IO CUInt+++socketClientGetSocketType ::+    (MonadIO m, SocketClientK a) =>+    a ->                                    -- _obj+    m SocketType+socketClientGetSocketType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_client_get_socket_type _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method SocketClient::get_timeout+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_client_get_timeout" g_socket_client_get_timeout :: +    Ptr SocketClient ->                     -- _obj : TInterface "Gio" "SocketClient"+    IO Word32+++socketClientGetTimeout ::+    (MonadIO m, SocketClientK a) =>+    a ->                                    -- _obj+    m Word32+socketClientGetTimeout _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_client_get_timeout _obj'+    touchManagedPtr _obj+    return result++-- method SocketClient::get_tls+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_client_get_tls" g_socket_client_get_tls :: +    Ptr SocketClient ->                     -- _obj : TInterface "Gio" "SocketClient"+    IO CInt+++socketClientGetTls ::+    (MonadIO m, SocketClientK a) =>+    a ->                                    -- _obj+    m Bool+socketClientGetTls _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_client_get_tls _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method SocketClient::get_tls_validation_flags+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TlsCertificateFlags"+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_client_get_tls_validation_flags" g_socket_client_get_tls_validation_flags :: +    Ptr SocketClient ->                     -- _obj : TInterface "Gio" "SocketClient"+    IO CUInt+++socketClientGetTlsValidationFlags ::+    (MonadIO m, SocketClientK a) =>+    a ->                                    -- _obj+    m [TlsCertificateFlags]+socketClientGetTlsValidationFlags _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_client_get_tls_validation_flags _obj'+    let result' = wordToGFlags result+    touchManagedPtr _obj+    return result'++-- method SocketClient::set_enable_proxy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "enable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "enable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_client_set_enable_proxy" g_socket_client_set_enable_proxy :: +    Ptr SocketClient ->                     -- _obj : TInterface "Gio" "SocketClient"+    CInt ->                                 -- enable : TBasicType TBoolean+    IO ()+++socketClientSetEnableProxy ::+    (MonadIO m, SocketClientK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- enable+    m ()+socketClientSetEnableProxy _obj enable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let enable' = (fromIntegral . fromEnum) enable+    g_socket_client_set_enable_proxy _obj' enable'+    touchManagedPtr _obj+    return ()++-- method SocketClient::set_family+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "family", argType = TInterface "Gio" "SocketFamily", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "family", argType = TInterface "Gio" "SocketFamily", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_client_set_family" g_socket_client_set_family :: +    Ptr SocketClient ->                     -- _obj : TInterface "Gio" "SocketClient"+    CUInt ->                                -- family : TInterface "Gio" "SocketFamily"+    IO ()+++socketClientSetFamily ::+    (MonadIO m, SocketClientK a) =>+    a ->                                    -- _obj+    SocketFamily ->                         -- family+    m ()+socketClientSetFamily _obj family = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let family' = (fromIntegral . fromEnum) family+    g_socket_client_set_family _obj' family'+    touchManagedPtr _obj+    return ()++-- method SocketClient::set_local_address+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "address", argType = TInterface "Gio" "SocketAddress", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "address", argType = TInterface "Gio" "SocketAddress", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_client_set_local_address" g_socket_client_set_local_address :: +    Ptr SocketClient ->                     -- _obj : TInterface "Gio" "SocketClient"+    Ptr SocketAddress ->                    -- address : TInterface "Gio" "SocketAddress"+    IO ()+++socketClientSetLocalAddress ::+    (MonadIO m, SocketClientK a, SocketAddressK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- address+    m ()+socketClientSetLocalAddress _obj address = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeAddress <- case address of+        Nothing -> return nullPtr+        Just jAddress -> do+            let jAddress' = unsafeManagedPtrCastPtr jAddress+            return jAddress'+    g_socket_client_set_local_address _obj' maybeAddress+    touchManagedPtr _obj+    whenJust address touchManagedPtr+    return ()++-- method SocketClient::set_protocol+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "protocol", argType = TInterface "Gio" "SocketProtocol", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "protocol", argType = TInterface "Gio" "SocketProtocol", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_client_set_protocol" g_socket_client_set_protocol :: +    Ptr SocketClient ->                     -- _obj : TInterface "Gio" "SocketClient"+    CUInt ->                                -- protocol : TInterface "Gio" "SocketProtocol"+    IO ()+++socketClientSetProtocol ::+    (MonadIO m, SocketClientK a) =>+    a ->                                    -- _obj+    SocketProtocol ->                       -- protocol+    m ()+socketClientSetProtocol _obj protocol = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let protocol' = (fromIntegral . fromEnum) protocol+    g_socket_client_set_protocol _obj' protocol'+    touchManagedPtr _obj+    return ()++-- method SocketClient::set_proxy_resolver+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "proxy_resolver", argType = TInterface "Gio" "ProxyResolver", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "proxy_resolver", argType = TInterface "Gio" "ProxyResolver", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_client_set_proxy_resolver" g_socket_client_set_proxy_resolver :: +    Ptr SocketClient ->                     -- _obj : TInterface "Gio" "SocketClient"+    Ptr ProxyResolver ->                    -- proxy_resolver : TInterface "Gio" "ProxyResolver"+    IO ()+++socketClientSetProxyResolver ::+    (MonadIO m, SocketClientK a, ProxyResolverK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- proxy_resolver+    m ()+socketClientSetProxyResolver _obj proxy_resolver = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeProxy_resolver <- case proxy_resolver of+        Nothing -> return nullPtr+        Just jProxy_resolver -> do+            let jProxy_resolver' = unsafeManagedPtrCastPtr jProxy_resolver+            return jProxy_resolver'+    g_socket_client_set_proxy_resolver _obj' maybeProxy_resolver+    touchManagedPtr _obj+    whenJust proxy_resolver touchManagedPtr+    return ()++-- method SocketClient::set_socket_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "Gio" "SocketType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "Gio" "SocketType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_client_set_socket_type" g_socket_client_set_socket_type :: +    Ptr SocketClient ->                     -- _obj : TInterface "Gio" "SocketClient"+    CUInt ->                                -- type : TInterface "Gio" "SocketType"+    IO ()+++socketClientSetSocketType ::+    (MonadIO m, SocketClientK a) =>+    a ->                                    -- _obj+    SocketType ->                           -- type+    m ()+socketClientSetSocketType _obj type_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let type_' = (fromIntegral . fromEnum) type_+    g_socket_client_set_socket_type _obj' type_'+    touchManagedPtr _obj+    return ()++-- method SocketClient::set_timeout+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "timeout", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "timeout", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_client_set_timeout" g_socket_client_set_timeout :: +    Ptr SocketClient ->                     -- _obj : TInterface "Gio" "SocketClient"+    Word32 ->                               -- timeout : TBasicType TUInt32+    IO ()+++socketClientSetTimeout ::+    (MonadIO m, SocketClientK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- timeout+    m ()+socketClientSetTimeout _obj timeout = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_socket_client_set_timeout _obj' timeout+    touchManagedPtr _obj+    return ()++-- method SocketClient::set_tls+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tls", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tls", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_client_set_tls" g_socket_client_set_tls :: +    Ptr SocketClient ->                     -- _obj : TInterface "Gio" "SocketClient"+    CInt ->                                 -- tls : TBasicType TBoolean+    IO ()+++socketClientSetTls ::+    (MonadIO m, SocketClientK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- tls+    m ()+socketClientSetTls _obj tls = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let tls' = (fromIntegral . fromEnum) tls+    g_socket_client_set_tls _obj' tls'+    touchManagedPtr _obj+    return ()++-- method SocketClient::set_tls_validation_flags+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "TlsCertificateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketClient", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "TlsCertificateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_client_set_tls_validation_flags" g_socket_client_set_tls_validation_flags :: +    Ptr SocketClient ->                     -- _obj : TInterface "Gio" "SocketClient"+    CUInt ->                                -- flags : TInterface "Gio" "TlsCertificateFlags"+    IO ()+++socketClientSetTlsValidationFlags ::+    (MonadIO m, SocketClientK a) =>+    a ->                                    -- _obj+    [TlsCertificateFlags] ->                -- flags+    m ()+socketClientSetTlsValidationFlags _obj flags = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    g_socket_client_set_tls_validation_flags _obj' flags'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Objects/SocketClient.hs-boot view
@@ -0,0 +1,23 @@+module GI.Gio.Objects.SocketClient where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype SocketClient = SocketClient (ForeignPtr SocketClient)+instance GObject SocketClient where+class GObject o => SocketClientK o+instance (GObject o, IsDescendantOf SocketClient o) => SocketClientK o+data SocketClientEnableProxyPropertyInfo+data SocketClientFamilyPropertyInfo+data SocketClientLocalAddressPropertyInfo+data SocketClientProtocolPropertyInfo+data SocketClientProxyResolverPropertyInfo+data SocketClientTimeoutPropertyInfo+data SocketClientTlsPropertyInfo+data SocketClientTlsValidationFlagsPropertyInfo+data SocketClientTypePropertyInfo+data SocketClientEventSignalInfo
+ GI/Gio/Objects/SocketConnection.hs view
@@ -0,0 +1,421 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.SocketConnection+    ( ++-- * Exported types+    SocketConnection(..)                    ,+    SocketConnectionK                       ,+    toSocketConnection                      ,+    noSocketConnection                      ,+++ -- * Methods+-- ** socketConnectionConnect+    socketConnectionConnect                 ,+++-- ** socketConnectionConnectAsync+    socketConnectionConnectAsync            ,+++-- ** socketConnectionConnectFinish+    socketConnectionConnectFinish           ,+++-- ** socketConnectionFactoryLookupType+    socketConnectionFactoryLookupType       ,+++-- ** socketConnectionFactoryRegisterType+    socketConnectionFactoryRegisterType     ,+++-- ** socketConnectionGetLocalAddress+    socketConnectionGetLocalAddress         ,+++-- ** socketConnectionGetRemoteAddress+    socketConnectionGetRemoteAddress        ,+++-- ** socketConnectionGetSocket+    socketConnectionGetSocket               ,+++-- ** socketConnectionIsConnected+    socketConnectionIsConnected             ,+++++ -- * Properties+-- ** Socket+    SocketConnectionSocketPropertyInfo      ,+    constructSocketConnectionSocket         ,+    getSocketConnectionSocket               ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype SocketConnection = SocketConnection (ForeignPtr SocketConnection)+foreign import ccall "g_socket_connection_get_type"+    c_g_socket_connection_get_type :: IO GType++type instance ParentTypes SocketConnection = SocketConnectionParentTypes+type SocketConnectionParentTypes = '[IOStream, GObject.Object]++instance GObject SocketConnection where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_socket_connection_get_type+    ++class GObject o => SocketConnectionK o+instance (GObject o, IsDescendantOf SocketConnection o) => SocketConnectionK o++toSocketConnection :: SocketConnectionK o => o -> IO SocketConnection+toSocketConnection = unsafeCastTo SocketConnection++noSocketConnection :: Maybe SocketConnection+noSocketConnection = Nothing++-- VVV Prop "socket"+   -- Type: TInterface "Gio" "Socket"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getSocketConnectionSocket :: (MonadIO m, SocketConnectionK o) => o -> m Socket+getSocketConnectionSocket obj = liftIO $ getObjectPropertyObject obj "socket" Socket++constructSocketConnectionSocket :: (SocketK a) => a -> IO ([Char], GValue)+constructSocketConnectionSocket val = constructObjectPropertyObject "socket" val++data SocketConnectionSocketPropertyInfo+instance AttrInfo SocketConnectionSocketPropertyInfo where+    type AttrAllowedOps SocketConnectionSocketPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SocketConnectionSocketPropertyInfo = SocketK+    type AttrBaseTypeConstraint SocketConnectionSocketPropertyInfo = SocketConnectionK+    type AttrGetType SocketConnectionSocketPropertyInfo = Socket+    type AttrLabel SocketConnectionSocketPropertyInfo = "SocketConnection::socket"+    attrGet _ = getSocketConnectionSocket+    attrSet _ = undefined+    attrConstruct _ = constructSocketConnectionSocket++type instance AttributeList SocketConnection = SocketConnectionAttributeList+type SocketConnectionAttributeList = ('[ '("closed", IOStreamClosedPropertyInfo), '("input-stream", IOStreamInputStreamPropertyInfo), '("output-stream", IOStreamOutputStreamPropertyInfo), '("socket", SocketConnectionSocketPropertyInfo)] :: [(Symbol, *)])++type instance SignalList SocketConnection = SocketConnectionSignalList+type SocketConnectionSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method SocketConnection::connect+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "address", argType = TInterface "Gio" "SocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "address", argType = TInterface "Gio" "SocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_connection_connect" g_socket_connection_connect :: +    Ptr SocketConnection ->                 -- _obj : TInterface "Gio" "SocketConnection"+    Ptr SocketAddress ->                    -- address : TInterface "Gio" "SocketAddress"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++socketConnectionConnect ::+    (MonadIO m, SocketConnectionK a, SocketAddressK b, CancellableK c) =>+    a ->                                    -- _obj+    b ->                                    -- address+    Maybe (c) ->                            -- cancellable+    m ()+socketConnectionConnect _obj address cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let address' = unsafeManagedPtrCastPtr address+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_socket_connection_connect _obj' address' maybeCancellable+        touchManagedPtr _obj+        touchManagedPtr address+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method SocketConnection::connect_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "address", argType = TInterface "Gio" "SocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "address", argType = TInterface "Gio" "SocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_connection_connect_async" g_socket_connection_connect_async :: +    Ptr SocketConnection ->                 -- _obj : TInterface "Gio" "SocketConnection"+    Ptr SocketAddress ->                    -- address : TInterface "Gio" "SocketAddress"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++socketConnectionConnectAsync ::+    (MonadIO m, SocketConnectionK a, SocketAddressK b, CancellableK c) =>+    a ->                                    -- _obj+    b ->                                    -- address+    Maybe (c) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+socketConnectionConnectAsync _obj address cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let address' = unsafeManagedPtrCastPtr address+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_socket_connection_connect_async _obj' address' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    touchManagedPtr address+    whenJust cancellable touchManagedPtr+    return ()++-- method SocketConnection::connect_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_connection_connect_finish" g_socket_connection_connect_finish :: +    Ptr SocketConnection ->                 -- _obj : TInterface "Gio" "SocketConnection"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++socketConnectionConnectFinish ::+    (MonadIO m, SocketConnectionK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+socketConnectionConnectFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_socket_connection_connect_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++-- method SocketConnection::get_local_address+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SocketAddress"+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_connection_get_local_address" g_socket_connection_get_local_address :: +    Ptr SocketConnection ->                 -- _obj : TInterface "Gio" "SocketConnection"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr SocketAddress)+++socketConnectionGetLocalAddress ::+    (MonadIO m, SocketConnectionK a) =>+    a ->                                    -- _obj+    m SocketAddress+socketConnectionGetLocalAddress _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    onException (do+        result <- propagateGError $ g_socket_connection_get_local_address _obj'+        checkUnexpectedReturnNULL "g_socket_connection_get_local_address" result+        result' <- (wrapObject SocketAddress) result+        touchManagedPtr _obj+        return result'+     ) (do+        return ()+     )++-- method SocketConnection::get_remote_address+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SocketAddress"+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_connection_get_remote_address" g_socket_connection_get_remote_address :: +    Ptr SocketConnection ->                 -- _obj : TInterface "Gio" "SocketConnection"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr SocketAddress)+++socketConnectionGetRemoteAddress ::+    (MonadIO m, SocketConnectionK a) =>+    a ->                                    -- _obj+    m SocketAddress+socketConnectionGetRemoteAddress _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    onException (do+        result <- propagateGError $ g_socket_connection_get_remote_address _obj'+        checkUnexpectedReturnNULL "g_socket_connection_get_remote_address" result+        result' <- (wrapObject SocketAddress) result+        touchManagedPtr _obj+        return result'+     ) (do+        return ()+     )++-- method SocketConnection::get_socket+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Socket"+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_connection_get_socket" g_socket_connection_get_socket :: +    Ptr SocketConnection ->                 -- _obj : TInterface "Gio" "SocketConnection"+    IO (Ptr Socket)+++socketConnectionGetSocket ::+    (MonadIO m, SocketConnectionK a) =>+    a ->                                    -- _obj+    m Socket+socketConnectionGetSocket _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_connection_get_socket _obj'+    checkUnexpectedReturnNULL "g_socket_connection_get_socket" result+    result' <- (newObject Socket) result+    touchManagedPtr _obj+    return result'++-- method SocketConnection::is_connected+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_connection_is_connected" g_socket_connection_is_connected :: +    Ptr SocketConnection ->                 -- _obj : TInterface "Gio" "SocketConnection"+    IO CInt+++socketConnectionIsConnected ::+    (MonadIO m, SocketConnectionK a) =>+    a ->                                    -- _obj+    m Bool+socketConnectionIsConnected _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_connection_is_connected _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method SocketConnection::factory_lookup_type+-- method type : MemberFunction+-- Args : [Arg {argName = "family", argType = TInterface "Gio" "SocketFamily", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "Gio" "SocketType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "protocol_id", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "family", argType = TInterface "Gio" "SocketFamily", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "Gio" "SocketType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "protocol_id", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TGType+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_connection_factory_lookup_type" g_socket_connection_factory_lookup_type :: +    CUInt ->                                -- family : TInterface "Gio" "SocketFamily"+    CUInt ->                                -- type : TInterface "Gio" "SocketType"+    Int32 ->                                -- protocol_id : TBasicType TInt32+    IO CGType+++socketConnectionFactoryLookupType ::+    (MonadIO m) =>+    SocketFamily ->                         -- family+    SocketType ->                           -- type+    Int32 ->                                -- protocol_id+    m GType+socketConnectionFactoryLookupType family type_ protocol_id = liftIO $ do+    let family' = (fromIntegral . fromEnum) family+    let type_' = (fromIntegral . fromEnum) type_+    result <- g_socket_connection_factory_lookup_type family' type_' protocol_id+    let result' = GType result+    return result'++-- method SocketConnection::factory_register_type+-- method type : MemberFunction+-- Args : [Arg {argName = "g_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "family", argType = TInterface "Gio" "SocketFamily", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "Gio" "SocketType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "protocol", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "g_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "family", argType = TInterface "Gio" "SocketFamily", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "Gio" "SocketType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "protocol", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_connection_factory_register_type" g_socket_connection_factory_register_type :: +    CGType ->                               -- g_type : TBasicType TGType+    CUInt ->                                -- family : TInterface "Gio" "SocketFamily"+    CUInt ->                                -- type : TInterface "Gio" "SocketType"+    Int32 ->                                -- protocol : TBasicType TInt32+    IO ()+++socketConnectionFactoryRegisterType ::+    (MonadIO m) =>+    GType ->                                -- g_type+    SocketFamily ->                         -- family+    SocketType ->                           -- type+    Int32 ->                                -- protocol+    m ()+socketConnectionFactoryRegisterType g_type family type_ protocol = liftIO $ do+    let g_type' = gtypeToCGType g_type+    let family' = (fromIntegral . fromEnum) family+    let type_' = (fromIntegral . fromEnum) type_+    g_socket_connection_factory_register_type g_type' family' type_' protocol+    return ()++
+ GI/Gio/Objects/SocketConnection.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gio.Objects.SocketConnection where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype SocketConnection = SocketConnection (ForeignPtr SocketConnection)+instance GObject SocketConnection where+class GObject o => SocketConnectionK o+instance (GObject o, IsDescendantOf SocketConnection o) => SocketConnectionK o+data SocketConnectionSocketPropertyInfo
+ GI/Gio/Objects/SocketControlMessage.hs view
@@ -0,0 +1,211 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.SocketControlMessage+    ( ++-- * Exported types+    SocketControlMessage(..)                ,+    SocketControlMessageK                   ,+    toSocketControlMessage                  ,+    noSocketControlMessage                  ,+++ -- * Methods+-- ** socketControlMessageDeserialize+    socketControlMessageDeserialize         ,+++-- ** socketControlMessageGetLevel+    socketControlMessageGetLevel            ,+++-- ** socketControlMessageGetMsgType+    socketControlMessageGetMsgType          ,+++-- ** socketControlMessageGetSize+    socketControlMessageGetSize             ,+++-- ** socketControlMessageSerialize+    socketControlMessageSerialize           ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype SocketControlMessage = SocketControlMessage (ForeignPtr SocketControlMessage)+foreign import ccall "g_socket_control_message_get_type"+    c_g_socket_control_message_get_type :: IO GType++type instance ParentTypes SocketControlMessage = SocketControlMessageParentTypes+type SocketControlMessageParentTypes = '[GObject.Object]++instance GObject SocketControlMessage where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_socket_control_message_get_type+    ++class GObject o => SocketControlMessageK o+instance (GObject o, IsDescendantOf SocketControlMessage o) => SocketControlMessageK o++toSocketControlMessage :: SocketControlMessageK o => o -> IO SocketControlMessage+toSocketControlMessage = unsafeCastTo SocketControlMessage++noSocketControlMessage :: Maybe SocketControlMessage+noSocketControlMessage = Nothing++type instance AttributeList SocketControlMessage = SocketControlMessageAttributeList+type SocketControlMessageAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList SocketControlMessage = SocketControlMessageSignalList+type SocketControlMessageSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method SocketControlMessage::get_level+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketControlMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketControlMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_control_message_get_level" g_socket_control_message_get_level :: +    Ptr SocketControlMessage ->             -- _obj : TInterface "Gio" "SocketControlMessage"+    IO Int32+++socketControlMessageGetLevel ::+    (MonadIO m, SocketControlMessageK a) =>+    a ->                                    -- _obj+    m Int32+socketControlMessageGetLevel _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_control_message_get_level _obj'+    touchManagedPtr _obj+    return result++-- method SocketControlMessage::get_msg_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketControlMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketControlMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_control_message_get_msg_type" g_socket_control_message_get_msg_type :: +    Ptr SocketControlMessage ->             -- _obj : TInterface "Gio" "SocketControlMessage"+    IO Int32+++socketControlMessageGetMsgType ::+    (MonadIO m, SocketControlMessageK a) =>+    a ->                                    -- _obj+    m Int32+socketControlMessageGetMsgType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_control_message_get_msg_type _obj'+    touchManagedPtr _obj+    return result++-- method SocketControlMessage::get_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketControlMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketControlMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_control_message_get_size" g_socket_control_message_get_size :: +    Ptr SocketControlMessage ->             -- _obj : TInterface "Gio" "SocketControlMessage"+    IO Word64+++socketControlMessageGetSize ::+    (MonadIO m, SocketControlMessageK a) =>+    a ->                                    -- _obj+    m Word64+socketControlMessageGetSize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_control_message_get_size _obj'+    touchManagedPtr _obj+    return result++-- method SocketControlMessage::serialize+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketControlMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketControlMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_control_message_serialize" g_socket_control_message_serialize :: +    Ptr SocketControlMessage ->             -- _obj : TInterface "Gio" "SocketControlMessage"+    Ptr () ->                               -- data : TBasicType TVoid+    IO ()+++socketControlMessageSerialize ::+    (MonadIO m, SocketControlMessageK a) =>+    a ->                                    -- _obj+    Ptr () ->                               -- data+    m ()+socketControlMessageSerialize _obj data_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_socket_control_message_serialize _obj' data_+    touchManagedPtr _obj+    return ()++-- method SocketControlMessage::deserialize+-- method type : MemberFunction+-- Args : [Arg {argName = "level", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "data", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "level", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "data", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SocketControlMessage"+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_control_message_deserialize" g_socket_control_message_deserialize :: +    Int32 ->                                -- level : TBasicType TInt32+    Int32 ->                                -- type : TBasicType TInt32+    Word64 ->                               -- size : TBasicType TUInt64+    Ptr Word8 ->                            -- data : TCArray False (-1) 2 (TBasicType TUInt8)+    IO (Ptr SocketControlMessage)+++socketControlMessageDeserialize ::+    (MonadIO m) =>+    Int32 ->                                -- level+    Int32 ->                                -- type+    ByteString ->                           -- data+    m SocketControlMessage+socketControlMessageDeserialize level type_ data_ = liftIO $ do+    let size = fromIntegral $ B.length data_+    data_' <- packByteString data_+    result <- g_socket_control_message_deserialize level type_ size data_'+    checkUnexpectedReturnNULL "g_socket_control_message_deserialize" result+    result' <- (wrapObject SocketControlMessage) result+    freeMem data_'+    return result'++
+ GI/Gio/Objects/SocketControlMessage.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Objects.SocketControlMessage where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype SocketControlMessage = SocketControlMessage (ForeignPtr SocketControlMessage)+instance GObject SocketControlMessage where+class GObject o => SocketControlMessageK o+instance (GObject o, IsDescendantOf SocketControlMessage o) => SocketControlMessageK o
+ GI/Gio/Objects/SocketListener.hs view
@@ -0,0 +1,708 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.SocketListener+    ( ++-- * Exported types+    SocketListener(..)                      ,+    SocketListenerK                         ,+    toSocketListener                        ,+    noSocketListener                        ,+++ -- * Methods+-- ** socketListenerAccept+    socketListenerAccept                    ,+++-- ** socketListenerAcceptAsync+    socketListenerAcceptAsync               ,+++-- ** socketListenerAcceptFinish+    socketListenerAcceptFinish              ,+++-- ** socketListenerAcceptSocket+    socketListenerAcceptSocket              ,+++-- ** socketListenerAcceptSocketAsync+    socketListenerAcceptSocketAsync         ,+++-- ** socketListenerAcceptSocketFinish+    socketListenerAcceptSocketFinish        ,+++-- ** socketListenerAddAddress+    socketListenerAddAddress                ,+++-- ** socketListenerAddAnyInetPort+    socketListenerAddAnyInetPort            ,+++-- ** socketListenerAddInetPort+    socketListenerAddInetPort               ,+++-- ** socketListenerAddSocket+    socketListenerAddSocket                 ,+++-- ** socketListenerClose+    socketListenerClose                     ,+++-- ** socketListenerNew+    socketListenerNew                       ,+++-- ** socketListenerSetBacklog+    socketListenerSetBacklog                ,+++++ -- * Properties+-- ** ListenBacklog+    SocketListenerListenBacklogPropertyInfo ,+    constructSocketListenerListenBacklog    ,+    getSocketListenerListenBacklog          ,+    setSocketListenerListenBacklog          ,+++++ -- * Signals+-- ** Event+    SocketListenerEventCallback             ,+    SocketListenerEventCallbackC            ,+    SocketListenerEventSignalInfo           ,+    afterSocketListenerEvent                ,+    mkSocketListenerEventCallback           ,+    noSocketListenerEventCallback           ,+    onSocketListenerEvent                   ,+    socketListenerEventCallbackWrapper      ,+    socketListenerEventClosure              ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype SocketListener = SocketListener (ForeignPtr SocketListener)+foreign import ccall "g_socket_listener_get_type"+    c_g_socket_listener_get_type :: IO GType++type instance ParentTypes SocketListener = SocketListenerParentTypes+type SocketListenerParentTypes = '[GObject.Object]++instance GObject SocketListener where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_socket_listener_get_type+    ++class GObject o => SocketListenerK o+instance (GObject o, IsDescendantOf SocketListener o) => SocketListenerK o++toSocketListener :: SocketListenerK o => o -> IO SocketListener+toSocketListener = unsafeCastTo SocketListener++noSocketListener :: Maybe SocketListener+noSocketListener = Nothing++-- signal SocketListener::event+type SocketListenerEventCallback =+    SocketListenerEvent ->+    Socket ->+    IO ()++noSocketListenerEventCallback :: Maybe SocketListenerEventCallback+noSocketListenerEventCallback = Nothing++type SocketListenerEventCallbackC =+    Ptr () ->                               -- object+    CUInt ->+    Ptr Socket ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkSocketListenerEventCallback :: SocketListenerEventCallbackC -> IO (FunPtr SocketListenerEventCallbackC)++socketListenerEventClosure :: SocketListenerEventCallback -> IO Closure+socketListenerEventClosure cb = newCClosure =<< mkSocketListenerEventCallback wrapped+    where wrapped = socketListenerEventCallbackWrapper cb++socketListenerEventCallbackWrapper ::+    SocketListenerEventCallback ->+    Ptr () ->+    CUInt ->+    Ptr Socket ->+    Ptr () ->+    IO ()+socketListenerEventCallbackWrapper _cb _ event socket _ = do+    let event' = (toEnum . fromIntegral) event+    socket' <- (newObject Socket) socket+    _cb  event' socket'++onSocketListenerEvent :: (GObject a, MonadIO m) => a -> SocketListenerEventCallback -> m SignalHandlerId+onSocketListenerEvent obj cb = liftIO $ connectSocketListenerEvent obj cb SignalConnectBefore+afterSocketListenerEvent :: (GObject a, MonadIO m) => a -> SocketListenerEventCallback -> m SignalHandlerId+afterSocketListenerEvent obj cb = connectSocketListenerEvent obj cb SignalConnectAfter++connectSocketListenerEvent :: (GObject a, MonadIO m) =>+                              a -> SocketListenerEventCallback -> SignalConnectMode -> m SignalHandlerId+connectSocketListenerEvent obj cb after = liftIO $ do+    cb' <- mkSocketListenerEventCallback (socketListenerEventCallbackWrapper cb)+    connectSignalFunPtr obj "event" cb' after++-- VVV Prop "listen-backlog"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getSocketListenerListenBacklog :: (MonadIO m, SocketListenerK o) => o -> m Int32+getSocketListenerListenBacklog obj = liftIO $ getObjectPropertyCInt obj "listen-backlog"++setSocketListenerListenBacklog :: (MonadIO m, SocketListenerK o) => o -> Int32 -> m ()+setSocketListenerListenBacklog obj val = liftIO $ setObjectPropertyCInt obj "listen-backlog" val++constructSocketListenerListenBacklog :: Int32 -> IO ([Char], GValue)+constructSocketListenerListenBacklog val = constructObjectPropertyCInt "listen-backlog" val++data SocketListenerListenBacklogPropertyInfo+instance AttrInfo SocketListenerListenBacklogPropertyInfo where+    type AttrAllowedOps SocketListenerListenBacklogPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SocketListenerListenBacklogPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint SocketListenerListenBacklogPropertyInfo = SocketListenerK+    type AttrGetType SocketListenerListenBacklogPropertyInfo = Int32+    type AttrLabel SocketListenerListenBacklogPropertyInfo = "SocketListener::listen-backlog"+    attrGet _ = getSocketListenerListenBacklog+    attrSet _ = setSocketListenerListenBacklog+    attrConstruct _ = constructSocketListenerListenBacklog++type instance AttributeList SocketListener = SocketListenerAttributeList+type SocketListenerAttributeList = ('[ '("listen-backlog", SocketListenerListenBacklogPropertyInfo)] :: [(Symbol, *)])++data SocketListenerEventSignalInfo+instance SignalInfo SocketListenerEventSignalInfo where+    type HaskellCallbackType SocketListenerEventSignalInfo = SocketListenerEventCallback+    connectSignal _ = connectSocketListenerEvent++type instance SignalList SocketListener = SocketListenerSignalList+type SocketListenerSignalList = ('[ '("event", SocketListenerEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method SocketListener::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gio" "SocketListener"+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_listener_new" g_socket_listener_new :: +    IO (Ptr SocketListener)+++socketListenerNew ::+    (MonadIO m) =>+    m SocketListener+socketListenerNew  = liftIO $ do+    result <- g_socket_listener_new+    checkUnexpectedReturnNULL "g_socket_listener_new" result+    result' <- (wrapObject SocketListener) result+    return result'++-- method SocketListener::accept+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketListener", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source_object", argType = TInterface "GObject" "Object", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketListener", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SocketConnection"+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_listener_accept" g_socket_listener_accept :: +    Ptr SocketListener ->                   -- _obj : TInterface "Gio" "SocketListener"+    Ptr (Ptr GObject.Object) ->             -- source_object : TInterface "GObject" "Object"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr SocketConnection)+++socketListenerAccept ::+    (MonadIO m, SocketListenerK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m (SocketConnection,GObject.Object)+socketListenerAccept _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    source_object <- allocMem :: IO (Ptr (Ptr GObject.Object))+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_socket_listener_accept _obj' source_object maybeCancellable+        checkUnexpectedReturnNULL "g_socket_listener_accept" result+        result' <- (wrapObject SocketConnection) result+        source_object' <- peek source_object+        source_object'' <- (newObject GObject.Object) source_object'+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem source_object+        return (result', source_object'')+     ) (do+        freeMem source_object+     )++-- method SocketListener::accept_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketListener", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketListener", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_listener_accept_async" g_socket_listener_accept_async :: +    Ptr SocketListener ->                   -- _obj : TInterface "Gio" "SocketListener"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++socketListenerAcceptAsync ::+    (MonadIO m, SocketListenerK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+socketListenerAcceptAsync _obj cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_socket_listener_accept_async _obj' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method SocketListener::accept_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketListener", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source_object", argType = TInterface "GObject" "Object", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketListener", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SocketConnection"+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_listener_accept_finish" g_socket_listener_accept_finish :: +    Ptr SocketListener ->                   -- _obj : TInterface "Gio" "SocketListener"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GObject.Object) ->             -- source_object : TInterface "GObject" "Object"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr SocketConnection)+++socketListenerAcceptFinish ::+    (MonadIO m, SocketListenerK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m (SocketConnection,GObject.Object)+socketListenerAcceptFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    source_object <- allocMem :: IO (Ptr (Ptr GObject.Object))+    onException (do+        result <- propagateGError $ g_socket_listener_accept_finish _obj' result_' source_object+        checkUnexpectedReturnNULL "g_socket_listener_accept_finish" result+        result' <- (wrapObject SocketConnection) result+        source_object' <- peek source_object+        source_object'' <- (newObject GObject.Object) source_object'+        touchManagedPtr _obj+        touchManagedPtr result_+        freeMem source_object+        return (result', source_object'')+     ) (do+        freeMem source_object+     )++-- method SocketListener::accept_socket+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketListener", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source_object", argType = TInterface "GObject" "Object", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketListener", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Socket"+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_listener_accept_socket" g_socket_listener_accept_socket :: +    Ptr SocketListener ->                   -- _obj : TInterface "Gio" "SocketListener"+    Ptr (Ptr GObject.Object) ->             -- source_object : TInterface "GObject" "Object"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Socket)+++socketListenerAcceptSocket ::+    (MonadIO m, SocketListenerK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m (Socket,GObject.Object)+socketListenerAcceptSocket _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    source_object <- allocMem :: IO (Ptr (Ptr GObject.Object))+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_socket_listener_accept_socket _obj' source_object maybeCancellable+        checkUnexpectedReturnNULL "g_socket_listener_accept_socket" result+        result' <- (wrapObject Socket) result+        source_object' <- peek source_object+        source_object'' <- (newObject GObject.Object) source_object'+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem source_object+        return (result', source_object'')+     ) (do+        freeMem source_object+     )++-- method SocketListener::accept_socket_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketListener", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketListener", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_listener_accept_socket_async" g_socket_listener_accept_socket_async :: +    Ptr SocketListener ->                   -- _obj : TInterface "Gio" "SocketListener"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++socketListenerAcceptSocketAsync ::+    (MonadIO m, SocketListenerK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+socketListenerAcceptSocketAsync _obj cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_socket_listener_accept_socket_async _obj' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method SocketListener::accept_socket_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketListener", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source_object", argType = TInterface "GObject" "Object", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketListener", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Socket"+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_listener_accept_socket_finish" g_socket_listener_accept_socket_finish :: +    Ptr SocketListener ->                   -- _obj : TInterface "Gio" "SocketListener"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GObject.Object) ->             -- source_object : TInterface "GObject" "Object"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Socket)+++socketListenerAcceptSocketFinish ::+    (MonadIO m, SocketListenerK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m (Socket,GObject.Object)+socketListenerAcceptSocketFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    source_object <- allocMem :: IO (Ptr (Ptr GObject.Object))+    onException (do+        result <- propagateGError $ g_socket_listener_accept_socket_finish _obj' result_' source_object+        checkUnexpectedReturnNULL "g_socket_listener_accept_socket_finish" result+        result' <- (wrapObject Socket) result+        source_object' <- peek source_object+        source_object'' <- (newObject GObject.Object) source_object'+        touchManagedPtr _obj+        touchManagedPtr result_+        freeMem source_object+        return (result', source_object'')+     ) (do+        freeMem source_object+     )++-- method SocketListener::add_address+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketListener", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "address", argType = TInterface "Gio" "SocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "Gio" "SocketType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "protocol", argType = TInterface "Gio" "SocketProtocol", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source_object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "effective_address", argType = TInterface "Gio" "SocketAddress", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketListener", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "address", argType = TInterface "Gio" "SocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "Gio" "SocketType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "protocol", argType = TInterface "Gio" "SocketProtocol", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source_object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_listener_add_address" g_socket_listener_add_address :: +    Ptr SocketListener ->                   -- _obj : TInterface "Gio" "SocketListener"+    Ptr SocketAddress ->                    -- address : TInterface "Gio" "SocketAddress"+    CUInt ->                                -- type : TInterface "Gio" "SocketType"+    CUInt ->                                -- protocol : TInterface "Gio" "SocketProtocol"+    Ptr GObject.Object ->                   -- source_object : TInterface "GObject" "Object"+    Ptr (Ptr SocketAddress) ->              -- effective_address : TInterface "Gio" "SocketAddress"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++socketListenerAddAddress ::+    (MonadIO m, SocketListenerK a, SocketAddressK b, GObject.ObjectK c) =>+    a ->                                    -- _obj+    b ->                                    -- address+    SocketType ->                           -- type+    SocketProtocol ->                       -- protocol+    Maybe (c) ->                            -- source_object+    m (SocketAddress)+socketListenerAddAddress _obj address type_ protocol source_object = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let address' = unsafeManagedPtrCastPtr address+    let type_' = (fromIntegral . fromEnum) type_+    let protocol' = (fromIntegral . fromEnum) protocol+    maybeSource_object <- case source_object of+        Nothing -> return nullPtr+        Just jSource_object -> do+            let jSource_object' = unsafeManagedPtrCastPtr jSource_object+            return jSource_object'+    effective_address <- allocMem :: IO (Ptr (Ptr SocketAddress))+    onException (do+        _ <- propagateGError $ g_socket_listener_add_address _obj' address' type_' protocol' maybeSource_object effective_address+        effective_address' <- peek effective_address+        effective_address'' <- (wrapObject SocketAddress) effective_address'+        touchManagedPtr _obj+        touchManagedPtr address+        whenJust source_object touchManagedPtr+        freeMem effective_address+        return effective_address''+     ) (do+        freeMem effective_address+     )++-- method SocketListener::add_any_inet_port+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketListener", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source_object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketListener", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source_object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt16+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_listener_add_any_inet_port" g_socket_listener_add_any_inet_port :: +    Ptr SocketListener ->                   -- _obj : TInterface "Gio" "SocketListener"+    Ptr GObject.Object ->                   -- source_object : TInterface "GObject" "Object"+    Ptr (Ptr GError) ->                     -- error+    IO Word16+++socketListenerAddAnyInetPort ::+    (MonadIO m, SocketListenerK a, GObject.ObjectK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- source_object+    m Word16+socketListenerAddAnyInetPort _obj source_object = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeSource_object <- case source_object of+        Nothing -> return nullPtr+        Just jSource_object -> do+            let jSource_object' = unsafeManagedPtrCastPtr jSource_object+            return jSource_object'+    onException (do+        result <- propagateGError $ g_socket_listener_add_any_inet_port _obj' maybeSource_object+        touchManagedPtr _obj+        whenJust source_object touchManagedPtr+        return result+     ) (do+        return ()+     )++-- method SocketListener::add_inet_port+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketListener", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "port", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source_object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketListener", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "port", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source_object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_listener_add_inet_port" g_socket_listener_add_inet_port :: +    Ptr SocketListener ->                   -- _obj : TInterface "Gio" "SocketListener"+    Word16 ->                               -- port : TBasicType TUInt16+    Ptr GObject.Object ->                   -- source_object : TInterface "GObject" "Object"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++socketListenerAddInetPort ::+    (MonadIO m, SocketListenerK a, GObject.ObjectK b) =>+    a ->                                    -- _obj+    Word16 ->                               -- port+    Maybe (b) ->                            -- source_object+    m ()+socketListenerAddInetPort _obj port source_object = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeSource_object <- case source_object of+        Nothing -> return nullPtr+        Just jSource_object -> do+            let jSource_object' = unsafeManagedPtrCastPtr jSource_object+            return jSource_object'+    onException (do+        _ <- propagateGError $ g_socket_listener_add_inet_port _obj' port maybeSource_object+        touchManagedPtr _obj+        whenJust source_object touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method SocketListener::add_socket+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketListener", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "socket", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source_object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketListener", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "socket", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source_object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_socket_listener_add_socket" g_socket_listener_add_socket :: +    Ptr SocketListener ->                   -- _obj : TInterface "Gio" "SocketListener"+    Ptr Socket ->                           -- socket : TInterface "Gio" "Socket"+    Ptr GObject.Object ->                   -- source_object : TInterface "GObject" "Object"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++socketListenerAddSocket ::+    (MonadIO m, SocketListenerK a, SocketK b, GObject.ObjectK c) =>+    a ->                                    -- _obj+    b ->                                    -- socket+    Maybe (c) ->                            -- source_object+    m ()+socketListenerAddSocket _obj socket source_object = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let socket' = unsafeManagedPtrCastPtr socket+    maybeSource_object <- case source_object of+        Nothing -> return nullPtr+        Just jSource_object -> do+            let jSource_object' = unsafeManagedPtrCastPtr jSource_object+            return jSource_object'+    onException (do+        _ <- propagateGError $ g_socket_listener_add_socket _obj' socket' maybeSource_object+        touchManagedPtr _obj+        touchManagedPtr socket+        whenJust source_object touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method SocketListener::close+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketListener", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketListener", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_listener_close" g_socket_listener_close :: +    Ptr SocketListener ->                   -- _obj : TInterface "Gio" "SocketListener"+    IO ()+++socketListenerClose ::+    (MonadIO m, SocketListenerK a) =>+    a ->                                    -- _obj+    m ()+socketListenerClose _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_socket_listener_close _obj'+    touchManagedPtr _obj+    return ()++-- method SocketListener::set_backlog+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketListener", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "listen_backlog", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketListener", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "listen_backlog", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_listener_set_backlog" g_socket_listener_set_backlog :: +    Ptr SocketListener ->                   -- _obj : TInterface "Gio" "SocketListener"+    Int32 ->                                -- listen_backlog : TBasicType TInt32+    IO ()+++socketListenerSetBacklog ::+    (MonadIO m, SocketListenerK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- listen_backlog+    m ()+socketListenerSetBacklog _obj listen_backlog = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_socket_listener_set_backlog _obj' listen_backlog+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Objects/SocketListener.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gio.Objects.SocketListener where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype SocketListener = SocketListener (ForeignPtr SocketListener)+instance GObject SocketListener where+class GObject o => SocketListenerK o+instance (GObject o, IsDescendantOf SocketListener o) => SocketListenerK o+data SocketListenerListenBacklogPropertyInfo+data SocketListenerEventSignalInfo
+ GI/Gio/Objects/SocketService.hs view
@@ -0,0 +1,279 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.SocketService+    ( ++-- * Exported types+    SocketService(..)                       ,+    SocketServiceK                          ,+    toSocketService                         ,+    noSocketService                         ,+++ -- * Methods+-- ** socketServiceIsActive+    socketServiceIsActive                   ,+++-- ** socketServiceNew+    socketServiceNew                        ,+++-- ** socketServiceStart+    socketServiceStart                      ,+++-- ** socketServiceStop+    socketServiceStop                       ,+++++ -- * Properties+-- ** Active+    SocketServiceActivePropertyInfo         ,+    constructSocketServiceActive            ,+    getSocketServiceActive                  ,+    setSocketServiceActive                  ,+++++ -- * Signals+-- ** Incoming+    SocketServiceIncomingCallback           ,+    SocketServiceIncomingCallbackC          ,+    SocketServiceIncomingSignalInfo         ,+    afterSocketServiceIncoming              ,+    mkSocketServiceIncomingCallback         ,+    noSocketServiceIncomingCallback         ,+    onSocketServiceIncoming                 ,+    socketServiceIncomingCallbackWrapper    ,+    socketServiceIncomingClosure            ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype SocketService = SocketService (ForeignPtr SocketService)+foreign import ccall "g_socket_service_get_type"+    c_g_socket_service_get_type :: IO GType++type instance ParentTypes SocketService = SocketServiceParentTypes+type SocketServiceParentTypes = '[SocketListener, GObject.Object]++instance GObject SocketService where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_socket_service_get_type+    ++class GObject o => SocketServiceK o+instance (GObject o, IsDescendantOf SocketService o) => SocketServiceK o++toSocketService :: SocketServiceK o => o -> IO SocketService+toSocketService = unsafeCastTo SocketService++noSocketService :: Maybe SocketService+noSocketService = Nothing++-- signal SocketService::incoming+type SocketServiceIncomingCallback =+    SocketConnection ->+    Maybe GObject.Object ->+    IO Bool++noSocketServiceIncomingCallback :: Maybe SocketServiceIncomingCallback+noSocketServiceIncomingCallback = Nothing++type SocketServiceIncomingCallbackC =+    Ptr () ->                               -- object+    Ptr SocketConnection ->+    Ptr GObject.Object ->+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkSocketServiceIncomingCallback :: SocketServiceIncomingCallbackC -> IO (FunPtr SocketServiceIncomingCallbackC)++socketServiceIncomingClosure :: SocketServiceIncomingCallback -> IO Closure+socketServiceIncomingClosure cb = newCClosure =<< mkSocketServiceIncomingCallback wrapped+    where wrapped = socketServiceIncomingCallbackWrapper cb++socketServiceIncomingCallbackWrapper ::+    SocketServiceIncomingCallback ->+    Ptr () ->+    Ptr SocketConnection ->+    Ptr GObject.Object ->+    Ptr () ->+    IO CInt+socketServiceIncomingCallbackWrapper _cb _ connection source_object _ = do+    connection' <- (newObject SocketConnection) connection+    maybeSource_object <-+        if source_object == nullPtr+        then return Nothing+        else do+            source_object' <- (newObject GObject.Object) source_object+            return $ Just source_object'+    result <- _cb  connection' maybeSource_object+    let result' = (fromIntegral . fromEnum) result+    return result'++onSocketServiceIncoming :: (GObject a, MonadIO m) => a -> SocketServiceIncomingCallback -> m SignalHandlerId+onSocketServiceIncoming obj cb = liftIO $ connectSocketServiceIncoming obj cb SignalConnectBefore+afterSocketServiceIncoming :: (GObject a, MonadIO m) => a -> SocketServiceIncomingCallback -> m SignalHandlerId+afterSocketServiceIncoming obj cb = connectSocketServiceIncoming obj cb SignalConnectAfter++connectSocketServiceIncoming :: (GObject a, MonadIO m) =>+                                a -> SocketServiceIncomingCallback -> SignalConnectMode -> m SignalHandlerId+connectSocketServiceIncoming obj cb after = liftIO $ do+    cb' <- mkSocketServiceIncomingCallback (socketServiceIncomingCallbackWrapper cb)+    connectSignalFunPtr obj "incoming" cb' after++-- VVV Prop "active"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getSocketServiceActive :: (MonadIO m, SocketServiceK o) => o -> m Bool+getSocketServiceActive obj = liftIO $ getObjectPropertyBool obj "active"++setSocketServiceActive :: (MonadIO m, SocketServiceK o) => o -> Bool -> m ()+setSocketServiceActive obj val = liftIO $ setObjectPropertyBool obj "active" val++constructSocketServiceActive :: Bool -> IO ([Char], GValue)+constructSocketServiceActive val = constructObjectPropertyBool "active" val++data SocketServiceActivePropertyInfo+instance AttrInfo SocketServiceActivePropertyInfo where+    type AttrAllowedOps SocketServiceActivePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SocketServiceActivePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint SocketServiceActivePropertyInfo = SocketServiceK+    type AttrGetType SocketServiceActivePropertyInfo = Bool+    type AttrLabel SocketServiceActivePropertyInfo = "SocketService::active"+    attrGet _ = getSocketServiceActive+    attrSet _ = setSocketServiceActive+    attrConstruct _ = constructSocketServiceActive++type instance AttributeList SocketService = SocketServiceAttributeList+type SocketServiceAttributeList = ('[ '("active", SocketServiceActivePropertyInfo), '("listen-backlog", SocketListenerListenBacklogPropertyInfo)] :: [(Symbol, *)])++data SocketServiceIncomingSignalInfo+instance SignalInfo SocketServiceIncomingSignalInfo where+    type HaskellCallbackType SocketServiceIncomingSignalInfo = SocketServiceIncomingCallback+    connectSignal _ = connectSocketServiceIncoming++type instance SignalList SocketService = SocketServiceSignalList+type SocketServiceSignalList = ('[ '("event", SocketListenerEventSignalInfo), '("incoming", SocketServiceIncomingSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method SocketService::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gio" "SocketService"+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_service_new" g_socket_service_new :: +    IO (Ptr SocketService)+++socketServiceNew ::+    (MonadIO m) =>+    m SocketService+socketServiceNew  = liftIO $ do+    result <- g_socket_service_new+    checkUnexpectedReturnNULL "g_socket_service_new" result+    result' <- (wrapObject SocketService) result+    return result'++-- method SocketService::is_active+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketService", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketService", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_service_is_active" g_socket_service_is_active :: +    Ptr SocketService ->                    -- _obj : TInterface "Gio" "SocketService"+    IO CInt+++socketServiceIsActive ::+    (MonadIO m, SocketServiceK a) =>+    a ->                                    -- _obj+    m Bool+socketServiceIsActive _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_socket_service_is_active _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method SocketService::start+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketService", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketService", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_service_start" g_socket_service_start :: +    Ptr SocketService ->                    -- _obj : TInterface "Gio" "SocketService"+    IO ()+++socketServiceStart ::+    (MonadIO m, SocketServiceK a) =>+    a ->                                    -- _obj+    m ()+socketServiceStart _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_socket_service_start _obj'+    touchManagedPtr _obj+    return ()++-- method SocketService::stop+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketService", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SocketService", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_socket_service_stop" g_socket_service_stop :: +    Ptr SocketService ->                    -- _obj : TInterface "Gio" "SocketService"+    IO ()+++socketServiceStop ::+    (MonadIO m, SocketServiceK a) =>+    a ->                                    -- _obj+    m ()+socketServiceStop _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_socket_service_stop _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Objects/SocketService.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gio.Objects.SocketService where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype SocketService = SocketService (ForeignPtr SocketService)+instance GObject SocketService where+class GObject o => SocketServiceK o+instance (GObject o, IsDescendantOf SocketService o) => SocketServiceK o+data SocketServiceActivePropertyInfo+data SocketServiceIncomingSignalInfo
+ GI/Gio/Objects/Subprocess.hs view
@@ -0,0 +1,1081 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.Subprocess+    ( ++-- * Exported types+    Subprocess(..)                          ,+    SubprocessK                             ,+    toSubprocess                            ,+    noSubprocess                            ,+++ -- * Methods+-- ** subprocessCommunicate+    subprocessCommunicate                   ,+++-- ** subprocessCommunicateAsync+    subprocessCommunicateAsync              ,+++-- ** subprocessCommunicateFinish+    subprocessCommunicateFinish             ,+++-- ** subprocessCommunicateUtf8+    subprocessCommunicateUtf8               ,+++-- ** subprocessCommunicateUtf8Async+    subprocessCommunicateUtf8Async          ,+++-- ** subprocessCommunicateUtf8Finish+    subprocessCommunicateUtf8Finish         ,+++-- ** subprocessForceExit+    subprocessForceExit                     ,+++-- ** subprocessGetExitStatus+    subprocessGetExitStatus                 ,+++-- ** subprocessGetIdentifier+    subprocessGetIdentifier                 ,+++-- ** subprocessGetIfExited+    subprocessGetIfExited                   ,+++-- ** subprocessGetIfSignaled+    subprocessGetIfSignaled                 ,+++-- ** subprocessGetStatus+    subprocessGetStatus                     ,+++-- ** subprocessGetStderrPipe+    subprocessGetStderrPipe                 ,+++-- ** subprocessGetStdinPipe+    subprocessGetStdinPipe                  ,+++-- ** subprocessGetStdoutPipe+    subprocessGetStdoutPipe                 ,+++-- ** subprocessGetSuccessful+    subprocessGetSuccessful                 ,+++-- ** subprocessGetTermSig+    subprocessGetTermSig                    ,+++-- ** subprocessNew+    subprocessNew                           ,+++-- ** subprocessSendSignal+    subprocessSendSignal                    ,+++-- ** subprocessWait+    subprocessWait                          ,+++-- ** subprocessWaitAsync+    subprocessWaitAsync                     ,+++-- ** subprocessWaitCheck+    subprocessWaitCheck                     ,+++-- ** subprocessWaitCheckAsync+    subprocessWaitCheckAsync                ,+++-- ** subprocessWaitCheckFinish+    subprocessWaitCheckFinish               ,+++-- ** subprocessWaitFinish+    subprocessWaitFinish                    ,+++++ -- * Properties+-- ** Argv+    SubprocessArgvPropertyInfo              ,+    constructSubprocessArgv                 ,+++-- ** Flags+    SubprocessFlagsPropertyInfo             ,+    constructSubprocessFlags                ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype Subprocess = Subprocess (ForeignPtr Subprocess)+foreign import ccall "g_subprocess_get_type"+    c_g_subprocess_get_type :: IO GType++type instance ParentTypes Subprocess = SubprocessParentTypes+type SubprocessParentTypes = '[GObject.Object, Initable]++instance GObject Subprocess where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_subprocess_get_type+    ++class GObject o => SubprocessK o+instance (GObject o, IsDescendantOf Subprocess o) => SubprocessK o++toSubprocess :: SubprocessK o => o -> IO Subprocess+toSubprocess = unsafeCastTo Subprocess++noSubprocess :: Maybe Subprocess+noSubprocess = Nothing++-- VVV Prop "argv"+   -- Type: TCArray True (-1) (-1) (TBasicType TUTF8)+   -- Flags: [PropertyWritable,PropertyConstructOnly]++constructSubprocessArgv :: [T.Text] -> IO ([Char], GValue)+constructSubprocessArgv val = constructObjectPropertyStringArray "argv" val++data SubprocessArgvPropertyInfo+instance AttrInfo SubprocessArgvPropertyInfo where+    type AttrAllowedOps SubprocessArgvPropertyInfo = '[ 'AttrConstruct]+    type AttrSetTypeConstraint SubprocessArgvPropertyInfo = (~) [T.Text]+    type AttrBaseTypeConstraint SubprocessArgvPropertyInfo = SubprocessK+    type AttrGetType SubprocessArgvPropertyInfo = ()+    type AttrLabel SubprocessArgvPropertyInfo = "Subprocess::argv"+    attrGet _ = undefined+    attrSet _ = undefined+    attrConstruct _ = constructSubprocessArgv++-- VVV Prop "flags"+   -- Type: TInterface "Gio" "SubprocessFlags"+   -- Flags: [PropertyWritable,PropertyConstructOnly]++constructSubprocessFlags :: [SubprocessFlags] -> IO ([Char], GValue)+constructSubprocessFlags val = constructObjectPropertyFlags "flags" val++data SubprocessFlagsPropertyInfo+instance AttrInfo SubprocessFlagsPropertyInfo where+    type AttrAllowedOps SubprocessFlagsPropertyInfo = '[ 'AttrConstruct]+    type AttrSetTypeConstraint SubprocessFlagsPropertyInfo = (~) [SubprocessFlags]+    type AttrBaseTypeConstraint SubprocessFlagsPropertyInfo = SubprocessK+    type AttrGetType SubprocessFlagsPropertyInfo = ()+    type AttrLabel SubprocessFlagsPropertyInfo = "Subprocess::flags"+    attrGet _ = undefined+    attrSet _ = undefined+    attrConstruct _ = constructSubprocessFlags++type instance AttributeList Subprocess = SubprocessAttributeList+type SubprocessAttributeList = ('[ '("argv", SubprocessArgvPropertyInfo), '("flags", SubprocessFlagsPropertyInfo)] :: [(Symbol, *)])++type instance SignalList Subprocess = SubprocessSignalList+type SubprocessSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Subprocess::new+-- method type : Constructor+-- Args : [Arg {argName = "argv", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "SubprocessFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "argv", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "SubprocessFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Subprocess"+-- throws : True+-- Skip return : False++foreign import ccall "g_subprocess_newv" g_subprocess_newv :: +    Ptr CString ->                          -- argv : TCArray True (-1) (-1) (TBasicType TUTF8)+    CUInt ->                                -- flags : TInterface "Gio" "SubprocessFlags"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Subprocess)+++subprocessNew ::+    (MonadIO m) =>+    [T.Text] ->                             -- argv+    [SubprocessFlags] ->                    -- flags+    m Subprocess+subprocessNew argv flags = liftIO $ do+    argv' <- packZeroTerminatedUTF8CArray argv+    let flags' = gflagsToWord flags+    onException (do+        result <- propagateGError $ g_subprocess_newv argv' flags'+        checkUnexpectedReturnNULL "g_subprocess_newv" result+        result' <- (wrapObject Subprocess) result+        mapZeroTerminatedCArray freeMem argv'+        freeMem argv'+        return result'+     ) (do+        mapZeroTerminatedCArray freeMem argv'+        freeMem argv'+     )++-- method Subprocess::communicate+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stdin_buf", argType = TInterface "GLib" "Bytes", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stdout_buf", argType = TInterface "GLib" "Bytes", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "stderr_buf", argType = TInterface "GLib" "Bytes", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stdin_buf", argType = TInterface "GLib" "Bytes", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_subprocess_communicate" g_subprocess_communicate :: +    Ptr Subprocess ->                       -- _obj : TInterface "Gio" "Subprocess"+    Ptr GLib.Bytes ->                       -- stdin_buf : TInterface "GLib" "Bytes"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GLib.Bytes) ->                 -- stdout_buf : TInterface "GLib" "Bytes"+    Ptr (Ptr GLib.Bytes) ->                 -- stderr_buf : TInterface "GLib" "Bytes"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++subprocessCommunicate ::+    (MonadIO m, SubprocessK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (GLib.Bytes) ->                   -- stdin_buf+    Maybe (b) ->                            -- cancellable+    m (GLib.Bytes,GLib.Bytes)+subprocessCommunicate _obj stdin_buf cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeStdin_buf <- case stdin_buf of+        Nothing -> return nullPtr+        Just jStdin_buf -> do+            let jStdin_buf' = unsafeManagedPtrGetPtr jStdin_buf+            return jStdin_buf'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    stdout_buf <- allocMem :: IO (Ptr (Ptr GLib.Bytes))+    stderr_buf <- allocMem :: IO (Ptr (Ptr GLib.Bytes))+    onException (do+        _ <- propagateGError $ g_subprocess_communicate _obj' maybeStdin_buf maybeCancellable stdout_buf stderr_buf+        stdout_buf' <- peek stdout_buf+        stdout_buf'' <- (wrapBoxed GLib.Bytes) stdout_buf'+        stderr_buf' <- peek stderr_buf+        stderr_buf'' <- (wrapBoxed GLib.Bytes) stderr_buf'+        touchManagedPtr _obj+        whenJust stdin_buf touchManagedPtr+        whenJust cancellable touchManagedPtr+        freeMem stdout_buf+        freeMem stderr_buf+        return (stdout_buf'', stderr_buf'')+     ) (do+        freeMem stdout_buf+        freeMem stderr_buf+     )++-- method Subprocess::communicate_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stdin_buf", argType = TInterface "GLib" "Bytes", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stdin_buf", argType = TInterface "GLib" "Bytes", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_subprocess_communicate_async" g_subprocess_communicate_async :: +    Ptr Subprocess ->                       -- _obj : TInterface "Gio" "Subprocess"+    Ptr GLib.Bytes ->                       -- stdin_buf : TInterface "GLib" "Bytes"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++subprocessCommunicateAsync ::+    (MonadIO m, SubprocessK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (GLib.Bytes) ->                   -- stdin_buf+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+subprocessCommunicateAsync _obj stdin_buf cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeStdin_buf <- case stdin_buf of+        Nothing -> return nullPtr+        Just jStdin_buf -> do+            let jStdin_buf' = unsafeManagedPtrGetPtr jStdin_buf+            return jStdin_buf'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_subprocess_communicate_async _obj' maybeStdin_buf maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust stdin_buf touchManagedPtr+    whenJust cancellable touchManagedPtr+    return ()++-- method Subprocess::communicate_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stdout_buf", argType = TInterface "GLib" "Bytes", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "stderr_buf", argType = TInterface "GLib" "Bytes", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_subprocess_communicate_finish" g_subprocess_communicate_finish :: +    Ptr Subprocess ->                       -- _obj : TInterface "Gio" "Subprocess"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GLib.Bytes) ->                 -- stdout_buf : TInterface "GLib" "Bytes"+    Ptr (Ptr GLib.Bytes) ->                 -- stderr_buf : TInterface "GLib" "Bytes"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++subprocessCommunicateFinish ::+    (MonadIO m, SubprocessK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m (GLib.Bytes,GLib.Bytes)+subprocessCommunicateFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    stdout_buf <- allocMem :: IO (Ptr (Ptr GLib.Bytes))+    stderr_buf <- allocMem :: IO (Ptr (Ptr GLib.Bytes))+    onException (do+        _ <- propagateGError $ g_subprocess_communicate_finish _obj' result_' stdout_buf stderr_buf+        stdout_buf' <- peek stdout_buf+        stdout_buf'' <- (wrapBoxed GLib.Bytes) stdout_buf'+        stderr_buf' <- peek stderr_buf+        stderr_buf'' <- (wrapBoxed GLib.Bytes) stderr_buf'+        touchManagedPtr _obj+        touchManagedPtr result_+        freeMem stdout_buf+        freeMem stderr_buf+        return (stdout_buf'', stderr_buf'')+     ) (do+        freeMem stdout_buf+        freeMem stderr_buf+     )++-- method Subprocess::communicate_utf8+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stdin_buf", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stdout_buf", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "stderr_buf", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stdin_buf", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_subprocess_communicate_utf8" g_subprocess_communicate_utf8 :: +    Ptr Subprocess ->                       -- _obj : TInterface "Gio" "Subprocess"+    CString ->                              -- stdin_buf : TBasicType TUTF8+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr CString ->                          -- stdout_buf : TBasicType TUTF8+    Ptr CString ->                          -- stderr_buf : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++subprocessCommunicateUtf8 ::+    (MonadIO m, SubprocessK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- stdin_buf+    Maybe (b) ->                            -- cancellable+    m (T.Text,T.Text)+subprocessCommunicateUtf8 _obj stdin_buf cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeStdin_buf <- case stdin_buf of+        Nothing -> return nullPtr+        Just jStdin_buf -> do+            jStdin_buf' <- textToCString jStdin_buf+            return jStdin_buf'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    stdout_buf <- allocMem :: IO (Ptr CString)+    stderr_buf <- allocMem :: IO (Ptr CString)+    onException (do+        _ <- propagateGError $ g_subprocess_communicate_utf8 _obj' maybeStdin_buf maybeCancellable stdout_buf stderr_buf+        stdout_buf' <- peek stdout_buf+        stdout_buf'' <- cstringToText stdout_buf'+        freeMem stdout_buf'+        stderr_buf' <- peek stderr_buf+        stderr_buf'' <- cstringToText stderr_buf'+        freeMem stderr_buf'+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        freeMem maybeStdin_buf+        freeMem stdout_buf+        freeMem stderr_buf+        return (stdout_buf'', stderr_buf'')+     ) (do+        freeMem maybeStdin_buf+        freeMem stdout_buf+        freeMem stderr_buf+     )++-- method Subprocess::communicate_utf8_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stdin_buf", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stdin_buf", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_subprocess_communicate_utf8_async" g_subprocess_communicate_utf8_async :: +    Ptr Subprocess ->                       -- _obj : TInterface "Gio" "Subprocess"+    CString ->                              -- stdin_buf : TBasicType TUTF8+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++subprocessCommunicateUtf8Async ::+    (MonadIO m, SubprocessK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- stdin_buf+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+subprocessCommunicateUtf8Async _obj stdin_buf cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeStdin_buf <- case stdin_buf of+        Nothing -> return nullPtr+        Just jStdin_buf -> do+            jStdin_buf' <- textToCString jStdin_buf+            return jStdin_buf'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_subprocess_communicate_utf8_async _obj' maybeStdin_buf maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    freeMem maybeStdin_buf+    return ()++-- method Subprocess::communicate_utf8_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stdout_buf", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "stderr_buf", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_subprocess_communicate_utf8_finish" g_subprocess_communicate_utf8_finish :: +    Ptr Subprocess ->                       -- _obj : TInterface "Gio" "Subprocess"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr CString ->                          -- stdout_buf : TBasicType TUTF8+    Ptr CString ->                          -- stderr_buf : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++subprocessCommunicateUtf8Finish ::+    (MonadIO m, SubprocessK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m (T.Text,T.Text)+subprocessCommunicateUtf8Finish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    stdout_buf <- allocMem :: IO (Ptr CString)+    stderr_buf <- allocMem :: IO (Ptr CString)+    onException (do+        _ <- propagateGError $ g_subprocess_communicate_utf8_finish _obj' result_' stdout_buf stderr_buf+        stdout_buf' <- peek stdout_buf+        stdout_buf'' <- cstringToText stdout_buf'+        freeMem stdout_buf'+        stderr_buf' <- peek stderr_buf+        stderr_buf'' <- cstringToText stderr_buf'+        freeMem stderr_buf'+        touchManagedPtr _obj+        touchManagedPtr result_+        freeMem stdout_buf+        freeMem stderr_buf+        return (stdout_buf'', stderr_buf'')+     ) (do+        freeMem stdout_buf+        freeMem stderr_buf+     )++-- method Subprocess::force_exit+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_subprocess_force_exit" g_subprocess_force_exit :: +    Ptr Subprocess ->                       -- _obj : TInterface "Gio" "Subprocess"+    IO ()+++subprocessForceExit ::+    (MonadIO m, SubprocessK a) =>+    a ->                                    -- _obj+    m ()+subprocessForceExit _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_subprocess_force_exit _obj'+    touchManagedPtr _obj+    return ()++-- method Subprocess::get_exit_status+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_subprocess_get_exit_status" g_subprocess_get_exit_status :: +    Ptr Subprocess ->                       -- _obj : TInterface "Gio" "Subprocess"+    IO Int32+++subprocessGetExitStatus ::+    (MonadIO m, SubprocessK a) =>+    a ->                                    -- _obj+    m Int32+subprocessGetExitStatus _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_subprocess_get_exit_status _obj'+    touchManagedPtr _obj+    return result++-- method Subprocess::get_identifier+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_subprocess_get_identifier" g_subprocess_get_identifier :: +    Ptr Subprocess ->                       -- _obj : TInterface "Gio" "Subprocess"+    IO CString+++subprocessGetIdentifier ::+    (MonadIO m, SubprocessK a) =>+    a ->                                    -- _obj+    m T.Text+subprocessGetIdentifier _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_subprocess_get_identifier _obj'+    checkUnexpectedReturnNULL "g_subprocess_get_identifier" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Subprocess::get_if_exited+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_subprocess_get_if_exited" g_subprocess_get_if_exited :: +    Ptr Subprocess ->                       -- _obj : TInterface "Gio" "Subprocess"+    IO CInt+++subprocessGetIfExited ::+    (MonadIO m, SubprocessK a) =>+    a ->                                    -- _obj+    m Bool+subprocessGetIfExited _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_subprocess_get_if_exited _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Subprocess::get_if_signaled+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_subprocess_get_if_signaled" g_subprocess_get_if_signaled :: +    Ptr Subprocess ->                       -- _obj : TInterface "Gio" "Subprocess"+    IO CInt+++subprocessGetIfSignaled ::+    (MonadIO m, SubprocessK a) =>+    a ->                                    -- _obj+    m Bool+subprocessGetIfSignaled _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_subprocess_get_if_signaled _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Subprocess::get_status+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_subprocess_get_status" g_subprocess_get_status :: +    Ptr Subprocess ->                       -- _obj : TInterface "Gio" "Subprocess"+    IO Int32+++subprocessGetStatus ::+    (MonadIO m, SubprocessK a) =>+    a ->                                    -- _obj+    m Int32+subprocessGetStatus _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_subprocess_get_status _obj'+    touchManagedPtr _obj+    return result++-- method Subprocess::get_stderr_pipe+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "InputStream"+-- throws : False+-- Skip return : False++foreign import ccall "g_subprocess_get_stderr_pipe" g_subprocess_get_stderr_pipe :: +    Ptr Subprocess ->                       -- _obj : TInterface "Gio" "Subprocess"+    IO (Ptr InputStream)+++subprocessGetStderrPipe ::+    (MonadIO m, SubprocessK a) =>+    a ->                                    -- _obj+    m InputStream+subprocessGetStderrPipe _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_subprocess_get_stderr_pipe _obj'+    checkUnexpectedReturnNULL "g_subprocess_get_stderr_pipe" result+    result' <- (newObject InputStream) result+    touchManagedPtr _obj+    return result'++-- method Subprocess::get_stdin_pipe+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "OutputStream"+-- throws : False+-- Skip return : False++foreign import ccall "g_subprocess_get_stdin_pipe" g_subprocess_get_stdin_pipe :: +    Ptr Subprocess ->                       -- _obj : TInterface "Gio" "Subprocess"+    IO (Ptr OutputStream)+++subprocessGetStdinPipe ::+    (MonadIO m, SubprocessK a) =>+    a ->                                    -- _obj+    m OutputStream+subprocessGetStdinPipe _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_subprocess_get_stdin_pipe _obj'+    checkUnexpectedReturnNULL "g_subprocess_get_stdin_pipe" result+    result' <- (newObject OutputStream) result+    touchManagedPtr _obj+    return result'++-- method Subprocess::get_stdout_pipe+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "InputStream"+-- throws : False+-- Skip return : False++foreign import ccall "g_subprocess_get_stdout_pipe" g_subprocess_get_stdout_pipe :: +    Ptr Subprocess ->                       -- _obj : TInterface "Gio" "Subprocess"+    IO (Ptr InputStream)+++subprocessGetStdoutPipe ::+    (MonadIO m, SubprocessK a) =>+    a ->                                    -- _obj+    m InputStream+subprocessGetStdoutPipe _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_subprocess_get_stdout_pipe _obj'+    checkUnexpectedReturnNULL "g_subprocess_get_stdout_pipe" result+    result' <- (newObject InputStream) result+    touchManagedPtr _obj+    return result'++-- method Subprocess::get_successful+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_subprocess_get_successful" g_subprocess_get_successful :: +    Ptr Subprocess ->                       -- _obj : TInterface "Gio" "Subprocess"+    IO CInt+++subprocessGetSuccessful ::+    (MonadIO m, SubprocessK a) =>+    a ->                                    -- _obj+    m Bool+subprocessGetSuccessful _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_subprocess_get_successful _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Subprocess::get_term_sig+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_subprocess_get_term_sig" g_subprocess_get_term_sig :: +    Ptr Subprocess ->                       -- _obj : TInterface "Gio" "Subprocess"+    IO Int32+++subprocessGetTermSig ::+    (MonadIO m, SubprocessK a) =>+    a ->                                    -- _obj+    m Int32+subprocessGetTermSig _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_subprocess_get_term_sig _obj'+    touchManagedPtr _obj+    return result++-- method Subprocess::send_signal+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "signal_num", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "signal_num", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_subprocess_send_signal" g_subprocess_send_signal :: +    Ptr Subprocess ->                       -- _obj : TInterface "Gio" "Subprocess"+    Int32 ->                                -- signal_num : TBasicType TInt32+    IO ()+++subprocessSendSignal ::+    (MonadIO m, SubprocessK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- signal_num+    m ()+subprocessSendSignal _obj signal_num = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_subprocess_send_signal _obj' signal_num+    touchManagedPtr _obj+    return ()++-- method Subprocess::wait+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_subprocess_wait" g_subprocess_wait :: +    Ptr Subprocess ->                       -- _obj : TInterface "Gio" "Subprocess"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++subprocessWait ::+    (MonadIO m, SubprocessK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m ()+subprocessWait _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_subprocess_wait _obj' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method Subprocess::wait_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_subprocess_wait_async" g_subprocess_wait_async :: +    Ptr Subprocess ->                       -- _obj : TInterface "Gio" "Subprocess"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++subprocessWaitAsync ::+    (MonadIO m, SubprocessK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+subprocessWaitAsync _obj cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_subprocess_wait_async _obj' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method Subprocess::wait_check+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_subprocess_wait_check" g_subprocess_wait_check :: +    Ptr Subprocess ->                       -- _obj : TInterface "Gio" "Subprocess"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++subprocessWaitCheck ::+    (MonadIO m, SubprocessK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m ()+subprocessWaitCheck _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_subprocess_wait_check _obj' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method Subprocess::wait_check_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_subprocess_wait_check_async" g_subprocess_wait_check_async :: +    Ptr Subprocess ->                       -- _obj : TInterface "Gio" "Subprocess"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++subprocessWaitCheckAsync ::+    (MonadIO m, SubprocessK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+subprocessWaitCheckAsync _obj cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_subprocess_wait_check_async _obj' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method Subprocess::wait_check_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_subprocess_wait_check_finish" g_subprocess_wait_check_finish :: +    Ptr Subprocess ->                       -- _obj : TInterface "Gio" "Subprocess"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++subprocessWaitCheckFinish ::+    (MonadIO m, SubprocessK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+subprocessWaitCheckFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_subprocess_wait_check_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++-- method Subprocess::wait_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Subprocess", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_subprocess_wait_finish" g_subprocess_wait_finish :: +    Ptr Subprocess ->                       -- _obj : TInterface "Gio" "Subprocess"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++subprocessWaitFinish ::+    (MonadIO m, SubprocessK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+subprocessWaitFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_subprocess_wait_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++
+ GI/Gio/Objects/Subprocess.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gio.Objects.Subprocess where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Subprocess = Subprocess (ForeignPtr Subprocess)+instance GObject Subprocess where+class GObject o => SubprocessK o+instance (GObject o, IsDescendantOf Subprocess o) => SubprocessK o+data SubprocessArgvPropertyInfo+data SubprocessFlagsPropertyInfo
+ GI/Gio/Objects/SubprocessLauncher.hs view
@@ -0,0 +1,611 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.SubprocessLauncher+    ( ++-- * Exported types+    SubprocessLauncher(..)                  ,+    SubprocessLauncherK                     ,+    toSubprocessLauncher                    ,+    noSubprocessLauncher                    ,+++ -- * Methods+-- ** subprocessLauncherGetenv+    subprocessLauncherGetenv                ,+++-- ** subprocessLauncherNew+    subprocessLauncherNew                   ,+++-- ** subprocessLauncherSetChildSetup+    subprocessLauncherSetChildSetup         ,+++-- ** subprocessLauncherSetCwd+    subprocessLauncherSetCwd                ,+++-- ** subprocessLauncherSetEnviron+    subprocessLauncherSetEnviron            ,+++-- ** subprocessLauncherSetFlags+    subprocessLauncherSetFlags              ,+++-- ** subprocessLauncherSetStderrFilePath+    subprocessLauncherSetStderrFilePath     ,+++-- ** subprocessLauncherSetStdinFilePath+    subprocessLauncherSetStdinFilePath      ,+++-- ** subprocessLauncherSetStdoutFilePath+    subprocessLauncherSetStdoutFilePath     ,+++-- ** subprocessLauncherSetenv+    subprocessLauncherSetenv                ,+++-- ** subprocessLauncherSpawnv+    subprocessLauncherSpawnv                ,+++-- ** subprocessLauncherTakeFd+    subprocessLauncherTakeFd                ,+++-- ** subprocessLauncherTakeStderrFd+    subprocessLauncherTakeStderrFd          ,+++-- ** subprocessLauncherTakeStdinFd+    subprocessLauncherTakeStdinFd           ,+++-- ** subprocessLauncherTakeStdoutFd+    subprocessLauncherTakeStdoutFd          ,+++-- ** subprocessLauncherUnsetenv+    subprocessLauncherUnsetenv              ,+++++ -- * Properties+-- ** Flags+    SubprocessLauncherFlagsPropertyInfo     ,+    constructSubprocessLauncherFlags        ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype SubprocessLauncher = SubprocessLauncher (ForeignPtr SubprocessLauncher)+foreign import ccall "g_subprocess_launcher_get_type"+    c_g_subprocess_launcher_get_type :: IO GType++type instance ParentTypes SubprocessLauncher = SubprocessLauncherParentTypes+type SubprocessLauncherParentTypes = '[GObject.Object]++instance GObject SubprocessLauncher where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_subprocess_launcher_get_type+    ++class GObject o => SubprocessLauncherK o+instance (GObject o, IsDescendantOf SubprocessLauncher o) => SubprocessLauncherK o++toSubprocessLauncher :: SubprocessLauncherK o => o -> IO SubprocessLauncher+toSubprocessLauncher = unsafeCastTo SubprocessLauncher++noSubprocessLauncher :: Maybe SubprocessLauncher+noSubprocessLauncher = Nothing++-- VVV Prop "flags"+   -- Type: TInterface "Gio" "SubprocessFlags"+   -- Flags: [PropertyWritable,PropertyConstructOnly]++constructSubprocessLauncherFlags :: [SubprocessFlags] -> IO ([Char], GValue)+constructSubprocessLauncherFlags val = constructObjectPropertyFlags "flags" val++data SubprocessLauncherFlagsPropertyInfo+instance AttrInfo SubprocessLauncherFlagsPropertyInfo where+    type AttrAllowedOps SubprocessLauncherFlagsPropertyInfo = '[ 'AttrConstruct]+    type AttrSetTypeConstraint SubprocessLauncherFlagsPropertyInfo = (~) [SubprocessFlags]+    type AttrBaseTypeConstraint SubprocessLauncherFlagsPropertyInfo = SubprocessLauncherK+    type AttrGetType SubprocessLauncherFlagsPropertyInfo = ()+    type AttrLabel SubprocessLauncherFlagsPropertyInfo = "SubprocessLauncher::flags"+    attrGet _ = undefined+    attrSet _ = undefined+    attrConstruct _ = constructSubprocessLauncherFlags++type instance AttributeList SubprocessLauncher = SubprocessLauncherAttributeList+type SubprocessLauncherAttributeList = ('[ '("flags", SubprocessLauncherFlagsPropertyInfo)] :: [(Symbol, *)])++type instance SignalList SubprocessLauncher = SubprocessLauncherSignalList+type SubprocessLauncherSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method SubprocessLauncher::new+-- method type : Constructor+-- Args : [Arg {argName = "flags", argType = TInterface "Gio" "SubprocessFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "flags", argType = TInterface "Gio" "SubprocessFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SubprocessLauncher"+-- throws : False+-- Skip return : False++foreign import ccall "g_subprocess_launcher_new" g_subprocess_launcher_new :: +    CUInt ->                                -- flags : TInterface "Gio" "SubprocessFlags"+    IO (Ptr SubprocessLauncher)+++subprocessLauncherNew ::+    (MonadIO m) =>+    [SubprocessFlags] ->                    -- flags+    m SubprocessLauncher+subprocessLauncherNew flags = liftIO $ do+    let flags' = gflagsToWord flags+    result <- g_subprocess_launcher_new flags'+    checkUnexpectedReturnNULL "g_subprocess_launcher_new" result+    result' <- (wrapObject SubprocessLauncher) result+    return result'++-- method SubprocessLauncher::getenv+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SubprocessLauncher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "variable", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SubprocessLauncher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "variable", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_subprocess_launcher_getenv" g_subprocess_launcher_getenv :: +    Ptr SubprocessLauncher ->               -- _obj : TInterface "Gio" "SubprocessLauncher"+    CString ->                              -- variable : TBasicType TUTF8+    IO CString+++subprocessLauncherGetenv ::+    (MonadIO m, SubprocessLauncherK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- variable+    m T.Text+subprocessLauncherGetenv _obj variable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    variable' <- textToCString variable+    result <- g_subprocess_launcher_getenv _obj' variable'+    checkUnexpectedReturnNULL "g_subprocess_launcher_getenv" result+    result' <- cstringToText result+    touchManagedPtr _obj+    freeMem variable'+    return result'++-- method SubprocessLauncher::set_child_setup+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SubprocessLauncher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child_setup", argType = TInterface "GLib" "SpawnChildSetupFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "destroy_notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SubprocessLauncher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child_setup", argType = TInterface "GLib" "SpawnChildSetupFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_subprocess_launcher_set_child_setup" g_subprocess_launcher_set_child_setup :: +    Ptr SubprocessLauncher ->               -- _obj : TInterface "Gio" "SubprocessLauncher"+    FunPtr GLib.SpawnChildSetupFuncC ->     -- child_setup : TInterface "GLib" "SpawnChildSetupFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- destroy_notify : TInterface "GLib" "DestroyNotify"+    IO ()+++subprocessLauncherSetChildSetup ::+    (MonadIO m, SubprocessLauncherK a) =>+    a ->                                    -- _obj+    GLib.SpawnChildSetupFunc ->             -- child_setup+    m ()+subprocessLauncherSetChildSetup _obj child_setup = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    child_setup' <- GLib.mkSpawnChildSetupFunc (GLib.spawnChildSetupFuncWrapper Nothing child_setup)+    let user_data = castFunPtrToPtr child_setup'+    let destroy_notify = safeFreeFunPtrPtr+    g_subprocess_launcher_set_child_setup _obj' child_setup' user_data destroy_notify+    touchManagedPtr _obj+    return ()++-- method SubprocessLauncher::set_cwd+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SubprocessLauncher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cwd", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SubprocessLauncher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cwd", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_subprocess_launcher_set_cwd" g_subprocess_launcher_set_cwd :: +    Ptr SubprocessLauncher ->               -- _obj : TInterface "Gio" "SubprocessLauncher"+    CString ->                              -- cwd : TBasicType TUTF8+    IO ()+++subprocessLauncherSetCwd ::+    (MonadIO m, SubprocessLauncherK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- cwd+    m ()+subprocessLauncherSetCwd _obj cwd = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    cwd' <- textToCString cwd+    g_subprocess_launcher_set_cwd _obj' cwd'+    touchManagedPtr _obj+    freeMem cwd'+    return ()++-- method SubprocessLauncher::set_environ+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SubprocessLauncher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "env", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SubprocessLauncher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "env", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_subprocess_launcher_set_environ" g_subprocess_launcher_set_environ :: +    Ptr SubprocessLauncher ->               -- _obj : TInterface "Gio" "SubprocessLauncher"+    CString ->                              -- env : TBasicType TUTF8+    IO ()+++subprocessLauncherSetEnviron ::+    (MonadIO m, SubprocessLauncherK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- env+    m ()+subprocessLauncherSetEnviron _obj env = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    env' <- textToCString env+    g_subprocess_launcher_set_environ _obj' env'+    touchManagedPtr _obj+    freeMem env'+    return ()++-- method SubprocessLauncher::set_flags+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SubprocessLauncher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "SubprocessFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SubprocessLauncher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "SubprocessFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_subprocess_launcher_set_flags" g_subprocess_launcher_set_flags :: +    Ptr SubprocessLauncher ->               -- _obj : TInterface "Gio" "SubprocessLauncher"+    CUInt ->                                -- flags : TInterface "Gio" "SubprocessFlags"+    IO ()+++subprocessLauncherSetFlags ::+    (MonadIO m, SubprocessLauncherK a) =>+    a ->                                    -- _obj+    [SubprocessFlags] ->                    -- flags+    m ()+subprocessLauncherSetFlags _obj flags = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    g_subprocess_launcher_set_flags _obj' flags'+    touchManagedPtr _obj+    return ()++-- method SubprocessLauncher::set_stderr_file_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SubprocessLauncher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SubprocessLauncher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_subprocess_launcher_set_stderr_file_path" g_subprocess_launcher_set_stderr_file_path :: +    Ptr SubprocessLauncher ->               -- _obj : TInterface "Gio" "SubprocessLauncher"+    CString ->                              -- path : TBasicType TUTF8+    IO ()+++subprocessLauncherSetStderrFilePath ::+    (MonadIO m, SubprocessLauncherK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- path+    m ()+subprocessLauncherSetStderrFilePath _obj path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    path' <- textToCString path+    g_subprocess_launcher_set_stderr_file_path _obj' path'+    touchManagedPtr _obj+    freeMem path'+    return ()++-- method SubprocessLauncher::set_stdin_file_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SubprocessLauncher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SubprocessLauncher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_subprocess_launcher_set_stdin_file_path" g_subprocess_launcher_set_stdin_file_path :: +    Ptr SubprocessLauncher ->               -- _obj : TInterface "Gio" "SubprocessLauncher"+    CString ->                              -- path : TBasicType TUTF8+    IO ()+++subprocessLauncherSetStdinFilePath ::+    (MonadIO m, SubprocessLauncherK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- path+    m ()+subprocessLauncherSetStdinFilePath _obj path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    path' <- textToCString path+    g_subprocess_launcher_set_stdin_file_path _obj' path'+    touchManagedPtr _obj+    freeMem path'+    return ()++-- method SubprocessLauncher::set_stdout_file_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SubprocessLauncher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SubprocessLauncher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_subprocess_launcher_set_stdout_file_path" g_subprocess_launcher_set_stdout_file_path :: +    Ptr SubprocessLauncher ->               -- _obj : TInterface "Gio" "SubprocessLauncher"+    CString ->                              -- path : TBasicType TUTF8+    IO ()+++subprocessLauncherSetStdoutFilePath ::+    (MonadIO m, SubprocessLauncherK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- path+    m ()+subprocessLauncherSetStdoutFilePath _obj path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    path' <- textToCString path+    g_subprocess_launcher_set_stdout_file_path _obj' path'+    touchManagedPtr _obj+    freeMem path'+    return ()++-- method SubprocessLauncher::setenv+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SubprocessLauncher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "variable", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "overwrite", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SubprocessLauncher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "variable", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "overwrite", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_subprocess_launcher_setenv" g_subprocess_launcher_setenv :: +    Ptr SubprocessLauncher ->               -- _obj : TInterface "Gio" "SubprocessLauncher"+    CString ->                              -- variable : TBasicType TUTF8+    CString ->                              -- value : TBasicType TUTF8+    CInt ->                                 -- overwrite : TBasicType TBoolean+    IO ()+++subprocessLauncherSetenv ::+    (MonadIO m, SubprocessLauncherK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- variable+    T.Text ->                               -- value+    Bool ->                                 -- overwrite+    m ()+subprocessLauncherSetenv _obj variable value overwrite = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    variable' <- textToCString variable+    value' <- textToCString value+    let overwrite' = (fromIntegral . fromEnum) overwrite+    g_subprocess_launcher_setenv _obj' variable' value' overwrite'+    touchManagedPtr _obj+    freeMem variable'+    freeMem value'+    return ()++-- method SubprocessLauncher::spawnv+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SubprocessLauncher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "argv", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SubprocessLauncher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "argv", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Subprocess"+-- throws : True+-- Skip return : False++foreign import ccall "g_subprocess_launcher_spawnv" g_subprocess_launcher_spawnv :: +    Ptr SubprocessLauncher ->               -- _obj : TInterface "Gio" "SubprocessLauncher"+    Ptr CString ->                          -- argv : TCArray True (-1) (-1) (TBasicType TUTF8)+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Subprocess)+++subprocessLauncherSpawnv ::+    (MonadIO m, SubprocessLauncherK a) =>+    a ->                                    -- _obj+    [T.Text] ->                             -- argv+    m Subprocess+subprocessLauncherSpawnv _obj argv = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    argv' <- packZeroTerminatedUTF8CArray argv+    onException (do+        result <- propagateGError $ g_subprocess_launcher_spawnv _obj' argv'+        checkUnexpectedReturnNULL "g_subprocess_launcher_spawnv" result+        result' <- (wrapObject Subprocess) result+        touchManagedPtr _obj+        mapZeroTerminatedCArray freeMem argv'+        freeMem argv'+        return result'+     ) (do+        mapZeroTerminatedCArray freeMem argv'+        freeMem argv'+     )++-- method SubprocessLauncher::take_fd+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SubprocessLauncher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source_fd", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "target_fd", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SubprocessLauncher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source_fd", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "target_fd", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_subprocess_launcher_take_fd" g_subprocess_launcher_take_fd :: +    Ptr SubprocessLauncher ->               -- _obj : TInterface "Gio" "SubprocessLauncher"+    Int32 ->                                -- source_fd : TBasicType TInt32+    Int32 ->                                -- target_fd : TBasicType TInt32+    IO ()+++subprocessLauncherTakeFd ::+    (MonadIO m, SubprocessLauncherK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- source_fd+    Int32 ->                                -- target_fd+    m ()+subprocessLauncherTakeFd _obj source_fd target_fd = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_subprocess_launcher_take_fd _obj' source_fd target_fd+    touchManagedPtr _obj+    return ()++-- method SubprocessLauncher::take_stderr_fd+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SubprocessLauncher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fd", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SubprocessLauncher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fd", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_subprocess_launcher_take_stderr_fd" g_subprocess_launcher_take_stderr_fd :: +    Ptr SubprocessLauncher ->               -- _obj : TInterface "Gio" "SubprocessLauncher"+    Int32 ->                                -- fd : TBasicType TInt32+    IO ()+++subprocessLauncherTakeStderrFd ::+    (MonadIO m, SubprocessLauncherK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- fd+    m ()+subprocessLauncherTakeStderrFd _obj fd = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_subprocess_launcher_take_stderr_fd _obj' fd+    touchManagedPtr _obj+    return ()++-- method SubprocessLauncher::take_stdin_fd+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SubprocessLauncher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fd", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SubprocessLauncher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fd", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_subprocess_launcher_take_stdin_fd" g_subprocess_launcher_take_stdin_fd :: +    Ptr SubprocessLauncher ->               -- _obj : TInterface "Gio" "SubprocessLauncher"+    Int32 ->                                -- fd : TBasicType TInt32+    IO ()+++subprocessLauncherTakeStdinFd ::+    (MonadIO m, SubprocessLauncherK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- fd+    m ()+subprocessLauncherTakeStdinFd _obj fd = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_subprocess_launcher_take_stdin_fd _obj' fd+    touchManagedPtr _obj+    return ()++-- method SubprocessLauncher::take_stdout_fd+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SubprocessLauncher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fd", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SubprocessLauncher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fd", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_subprocess_launcher_take_stdout_fd" g_subprocess_launcher_take_stdout_fd :: +    Ptr SubprocessLauncher ->               -- _obj : TInterface "Gio" "SubprocessLauncher"+    Int32 ->                                -- fd : TBasicType TInt32+    IO ()+++subprocessLauncherTakeStdoutFd ::+    (MonadIO m, SubprocessLauncherK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- fd+    m ()+subprocessLauncherTakeStdoutFd _obj fd = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_subprocess_launcher_take_stdout_fd _obj' fd+    touchManagedPtr _obj+    return ()++-- method SubprocessLauncher::unsetenv+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SubprocessLauncher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "variable", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SubprocessLauncher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "variable", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_subprocess_launcher_unsetenv" g_subprocess_launcher_unsetenv :: +    Ptr SubprocessLauncher ->               -- _obj : TInterface "Gio" "SubprocessLauncher"+    CString ->                              -- variable : TBasicType TUTF8+    IO ()+++subprocessLauncherUnsetenv ::+    (MonadIO m, SubprocessLauncherK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- variable+    m ()+subprocessLauncherUnsetenv _obj variable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    variable' <- textToCString variable+    g_subprocess_launcher_unsetenv _obj' variable'+    touchManagedPtr _obj+    freeMem variable'+    return ()++
+ GI/Gio/Objects/SubprocessLauncher.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gio.Objects.SubprocessLauncher where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype SubprocessLauncher = SubprocessLauncher (ForeignPtr SubprocessLauncher)+instance GObject SubprocessLauncher where+class GObject o => SubprocessLauncherK o+instance (GObject o, IsDescendantOf SubprocessLauncher o) => SubprocessLauncherK o+data SubprocessLauncherFlagsPropertyInfo
+ GI/Gio/Objects/Task.hs view
@@ -0,0 +1,947 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.Task+    ( ++-- * Exported types+    Task(..)                                ,+    TaskK                                   ,+    toTask                                  ,+    noTask                                  ,+++ -- * Methods+-- ** taskGetCancellable+    taskGetCancellable                      ,+++-- ** taskGetCheckCancellable+    taskGetCheckCancellable                 ,+++-- ** taskGetCompleted+    taskGetCompleted                        ,+++-- ** taskGetContext+    taskGetContext                          ,+++-- ** taskGetPriority+    taskGetPriority                         ,+++-- ** taskGetReturnOnCancel+    taskGetReturnOnCancel                   ,+++-- ** taskGetSourceObject+    taskGetSourceObject                     ,+++-- ** taskGetSourceTag+    taskGetSourceTag                        ,+++-- ** taskGetTaskData+    taskGetTaskData                         ,+++-- ** taskHadError+    taskHadError                            ,+++-- ** taskIsValid+    taskIsValid                             ,+++-- ** taskNew+    taskNew                                 ,+++-- ** taskPropagateBoolean+    taskPropagateBoolean                    ,+++-- ** taskPropagateInt+    taskPropagateInt                        ,+++-- ** taskPropagatePointer+    taskPropagatePointer                    ,+++-- ** taskReportError+    taskReportError                         ,+++-- ** taskReturnBoolean+    taskReturnBoolean                       ,+++-- ** taskReturnError+    taskReturnError                         ,+++-- ** taskReturnErrorIfCancelled+    taskReturnErrorIfCancelled              ,+++-- ** taskReturnInt+    taskReturnInt                           ,+++-- ** taskReturnPointer+    taskReturnPointer                       ,+++-- ** taskSetCheckCancellable+    taskSetCheckCancellable                 ,+++-- ** taskSetPriority+    taskSetPriority                         ,+++-- ** taskSetReturnOnCancel+    taskSetReturnOnCancel                   ,+++-- ** taskSetSourceTag+    taskSetSourceTag                        ,+++-- ** taskSetTaskData+    taskSetTaskData                         ,+++++ -- * Properties+-- ** Completed+    TaskCompletedPropertyInfo               ,+    getTaskCompleted                        ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype Task = Task (ForeignPtr Task)+foreign import ccall "g_task_get_type"+    c_g_task_get_type :: IO GType++type instance ParentTypes Task = TaskParentTypes+type TaskParentTypes = '[GObject.Object, AsyncResult]++instance GObject Task where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_task_get_type+    ++class GObject o => TaskK o+instance (GObject o, IsDescendantOf Task o) => TaskK o++toTask :: TaskK o => o -> IO Task+toTask = unsafeCastTo Task++noTask :: Maybe Task+noTask = Nothing++-- VVV Prop "completed"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getTaskCompleted :: (MonadIO m, TaskK o) => o -> m Bool+getTaskCompleted obj = liftIO $ getObjectPropertyBool obj "completed"++data TaskCompletedPropertyInfo+instance AttrInfo TaskCompletedPropertyInfo where+    type AttrAllowedOps TaskCompletedPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint TaskCompletedPropertyInfo = (~) ()+    type AttrBaseTypeConstraint TaskCompletedPropertyInfo = TaskK+    type AttrGetType TaskCompletedPropertyInfo = Bool+    type AttrLabel TaskCompletedPropertyInfo = "Task::completed"+    attrGet _ = getTaskCompleted+    attrSet _ = undefined+    attrConstruct _ = undefined++type instance AttributeList Task = TaskAttributeList+type TaskAttributeList = ('[ '("completed", TaskCompletedPropertyInfo)] :: [(Symbol, *)])++type instance SignalList Task = TaskSignalList+type TaskSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Task::new+-- method type : Constructor+-- Args : [Arg {argName = "source_object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "source_object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Task"+-- throws : False+-- Skip return : False++foreign import ccall "g_task_new" g_task_new :: +    Ptr GObject.Object ->                   -- source_object : TInterface "GObject" "Object"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- callback_data : TBasicType TVoid+    IO (Ptr Task)+++taskNew ::+    (MonadIO m, GObject.ObjectK a, CancellableK b) =>+    Maybe (a) ->                            -- source_object+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m Task+taskNew source_object cancellable callback = liftIO $ do+    maybeSource_object <- case source_object of+        Nothing -> return nullPtr+        Just jSource_object -> do+            let jSource_object' = unsafeManagedPtrCastPtr jSource_object+            return jSource_object'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let callback_data = nullPtr+    result <- g_task_new maybeSource_object maybeCancellable maybeCallback callback_data+    checkUnexpectedReturnNULL "g_task_new" result+    result' <- (wrapObject Task) result+    whenJust source_object touchManagedPtr+    whenJust cancellable touchManagedPtr+    return result'++-- method Task::get_cancellable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Cancellable"+-- throws : False+-- Skip return : False++foreign import ccall "g_task_get_cancellable" g_task_get_cancellable :: +    Ptr Task ->                             -- _obj : TInterface "Gio" "Task"+    IO (Ptr Cancellable)+++taskGetCancellable ::+    (MonadIO m, TaskK a) =>+    a ->                                    -- _obj+    m Cancellable+taskGetCancellable _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_task_get_cancellable _obj'+    checkUnexpectedReturnNULL "g_task_get_cancellable" result+    result' <- (newObject Cancellable) result+    touchManagedPtr _obj+    return result'++-- method Task::get_check_cancellable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_task_get_check_cancellable" g_task_get_check_cancellable :: +    Ptr Task ->                             -- _obj : TInterface "Gio" "Task"+    IO CInt+++taskGetCheckCancellable ::+    (MonadIO m, TaskK a) =>+    a ->                                    -- _obj+    m Bool+taskGetCheckCancellable _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_task_get_check_cancellable _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Task::get_completed+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_task_get_completed" g_task_get_completed :: +    Ptr Task ->                             -- _obj : TInterface "Gio" "Task"+    IO CInt+++taskGetCompleted ::+    (MonadIO m, TaskK a) =>+    a ->                                    -- _obj+    m Bool+taskGetCompleted _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_task_get_completed _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Task::get_context+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GLib" "MainContext"+-- throws : False+-- Skip return : False++foreign import ccall "g_task_get_context" g_task_get_context :: +    Ptr Task ->                             -- _obj : TInterface "Gio" "Task"+    IO (Ptr GLib.MainContext)+++taskGetContext ::+    (MonadIO m, TaskK a) =>+    a ->                                    -- _obj+    m GLib.MainContext+taskGetContext _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_task_get_context _obj'+    checkUnexpectedReturnNULL "g_task_get_context" result+    result' <- (newBoxed GLib.MainContext) result+    touchManagedPtr _obj+    return result'++-- method Task::get_priority+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_task_get_priority" g_task_get_priority :: +    Ptr Task ->                             -- _obj : TInterface "Gio" "Task"+    IO Int32+++taskGetPriority ::+    (MonadIO m, TaskK a) =>+    a ->                                    -- _obj+    m Int32+taskGetPriority _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_task_get_priority _obj'+    touchManagedPtr _obj+    return result++-- method Task::get_return_on_cancel+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_task_get_return_on_cancel" g_task_get_return_on_cancel :: +    Ptr Task ->                             -- _obj : TInterface "Gio" "Task"+    IO CInt+++taskGetReturnOnCancel ::+    (MonadIO m, TaskK a) =>+    a ->                                    -- _obj+    m Bool+taskGetReturnOnCancel _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_task_get_return_on_cancel _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Task::get_source_object+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GObject" "Object"+-- throws : False+-- Skip return : False++foreign import ccall "g_task_get_source_object" g_task_get_source_object :: +    Ptr Task ->                             -- _obj : TInterface "Gio" "Task"+    IO (Ptr GObject.Object)+++taskGetSourceObject ::+    (MonadIO m, TaskK a) =>+    a ->                                    -- _obj+    m GObject.Object+taskGetSourceObject _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_task_get_source_object _obj'+    checkUnexpectedReturnNULL "g_task_get_source_object" result+    result' <- (newObject GObject.Object) result+    touchManagedPtr _obj+    return result'++-- method Task::get_source_tag+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_task_get_source_tag" g_task_get_source_tag :: +    Ptr Task ->                             -- _obj : TInterface "Gio" "Task"+    IO ()+++taskGetSourceTag ::+    (MonadIO m, TaskK a) =>+    a ->                                    -- _obj+    m ()+taskGetSourceTag _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_task_get_source_tag _obj'+    touchManagedPtr _obj+    return ()++-- method Task::get_task_data+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_task_get_task_data" g_task_get_task_data :: +    Ptr Task ->                             -- _obj : TInterface "Gio" "Task"+    IO ()+++taskGetTaskData ::+    (MonadIO m, TaskK a) =>+    a ->                                    -- _obj+    m ()+taskGetTaskData _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_task_get_task_data _obj'+    touchManagedPtr _obj+    return ()++-- method Task::had_error+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_task_had_error" g_task_had_error :: +    Ptr Task ->                             -- _obj : TInterface "Gio" "Task"+    IO CInt+++taskHadError ::+    (MonadIO m, TaskK a) =>+    a ->                                    -- _obj+    m Bool+taskHadError _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_task_had_error _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Task::propagate_boolean+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_task_propagate_boolean" g_task_propagate_boolean :: +    Ptr Task ->                             -- _obj : TInterface "Gio" "Task"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++taskPropagateBoolean ::+    (MonadIO m, TaskK a) =>+    a ->                                    -- _obj+    m ()+taskPropagateBoolean _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    onException (do+        _ <- propagateGError $ g_task_propagate_boolean _obj'+        touchManagedPtr _obj+        return ()+     ) (do+        return ()+     )++-- method Task::propagate_int+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : True+-- Skip return : False++foreign import ccall "g_task_propagate_int" g_task_propagate_int :: +    Ptr Task ->                             -- _obj : TInterface "Gio" "Task"+    Ptr (Ptr GError) ->                     -- error+    IO Int64+++taskPropagateInt ::+    (MonadIO m, TaskK a) =>+    a ->                                    -- _obj+    m Int64+taskPropagateInt _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    onException (do+        result <- propagateGError $ g_task_propagate_int _obj'+        touchManagedPtr _obj+        return result+     ) (do+        return ()+     )++-- method Task::propagate_pointer+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : True+-- Skip return : False++foreign import ccall "g_task_propagate_pointer" g_task_propagate_pointer :: +    Ptr Task ->                             -- _obj : TInterface "Gio" "Task"+    Ptr (Ptr GError) ->                     -- error+    IO ()+++taskPropagatePointer ::+    (MonadIO m, TaskK a) =>+    a ->                                    -- _obj+    m ()+taskPropagatePointer _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    onException (do+        propagateGError $ g_task_propagate_pointer _obj'+        touchManagedPtr _obj+        return ()+     ) (do+        return ()+     )++-- method Task::return_boolean+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_task_return_boolean" g_task_return_boolean :: +    Ptr Task ->                             -- _obj : TInterface "Gio" "Task"+    CInt ->                                 -- result : TBasicType TBoolean+    IO ()+++taskReturnBoolean ::+    (MonadIO m, TaskK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- result+    m ()+taskReturnBoolean _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = (fromIntegral . fromEnum) result_+    g_task_return_boolean _obj' result_'+    touchManagedPtr _obj+    return ()++-- method Task::return_error+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_task_return_error" g_task_return_error :: +    Ptr Task ->                             -- _obj : TInterface "Gio" "Task"+    Ptr GError ->                           -- error : TError+    IO ()+++taskReturnError ::+    (MonadIO m, TaskK a) =>+    a ->                                    -- _obj+    GError ->                               -- error+    m ()+taskReturnError _obj error_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    error_' <- copyBoxed error_+    g_task_return_error _obj' error_'+    touchManagedPtr _obj+    touchManagedPtr error_+    return ()++-- method Task::return_error_if_cancelled+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_task_return_error_if_cancelled" g_task_return_error_if_cancelled :: +    Ptr Task ->                             -- _obj : TInterface "Gio" "Task"+    IO CInt+++taskReturnErrorIfCancelled ::+    (MonadIO m, TaskK a) =>+    a ->                                    -- _obj+    m Bool+taskReturnErrorIfCancelled _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_task_return_error_if_cancelled _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Task::return_int+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_task_return_int" g_task_return_int :: +    Ptr Task ->                             -- _obj : TInterface "Gio" "Task"+    Int64 ->                                -- result : TBasicType TInt64+    IO ()+++taskReturnInt ::+    (MonadIO m, TaskK a) =>+    a ->                                    -- _obj+    Int64 ->                                -- result+    m ()+taskReturnInt _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_task_return_int _obj' result_+    touchManagedPtr _obj+    return ()++-- method Task::return_pointer+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "result_destroy", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "result_destroy", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_task_return_pointer" g_task_return_pointer :: +    Ptr Task ->                             -- _obj : TInterface "Gio" "Task"+    Ptr () ->                               -- result : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- result_destroy : TInterface "GLib" "DestroyNotify"+    IO ()+++taskReturnPointer ::+    (MonadIO m, TaskK a) =>+    a ->                                    -- _obj+    Maybe (Ptr ()) ->                       -- result+    Maybe (GLib.DestroyNotify) ->           -- result_destroy+    m ()+taskReturnPointer _obj result_ result_destroy = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeResult_ <- case result_ of+        Nothing -> return nullPtr+        Just jResult_ -> do+            return jResult_+    ptrresult_destroy <- callocMem :: IO (Ptr (FunPtr GLib.DestroyNotifyC))+    maybeResult_destroy <- case result_destroy of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jResult_destroy -> do+            jResult_destroy' <- GLib.mkDestroyNotify (GLib.destroyNotifyWrapper (Just ptrresult_destroy) jResult_destroy)+            poke ptrresult_destroy jResult_destroy'+            return jResult_destroy'+    g_task_return_pointer _obj' maybeResult_ maybeResult_destroy+    touchManagedPtr _obj+    return ()++-- method Task::set_check_cancellable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "check_cancellable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "check_cancellable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_task_set_check_cancellable" g_task_set_check_cancellable :: +    Ptr Task ->                             -- _obj : TInterface "Gio" "Task"+    CInt ->                                 -- check_cancellable : TBasicType TBoolean+    IO ()+++taskSetCheckCancellable ::+    (MonadIO m, TaskK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- check_cancellable+    m ()+taskSetCheckCancellable _obj check_cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let check_cancellable' = (fromIntegral . fromEnum) check_cancellable+    g_task_set_check_cancellable _obj' check_cancellable'+    touchManagedPtr _obj+    return ()++-- method Task::set_priority+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_task_set_priority" g_task_set_priority :: +    Ptr Task ->                             -- _obj : TInterface "Gio" "Task"+    Int32 ->                                -- priority : TBasicType TInt32+    IO ()+++taskSetPriority ::+    (MonadIO m, TaskK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- priority+    m ()+taskSetPriority _obj priority = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_task_set_priority _obj' priority+    touchManagedPtr _obj+    return ()++-- method Task::set_return_on_cancel+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "return_on_cancel", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "return_on_cancel", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_task_set_return_on_cancel" g_task_set_return_on_cancel :: +    Ptr Task ->                             -- _obj : TInterface "Gio" "Task"+    CInt ->                                 -- return_on_cancel : TBasicType TBoolean+    IO CInt+++taskSetReturnOnCancel ::+    (MonadIO m, TaskK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- return_on_cancel+    m Bool+taskSetReturnOnCancel _obj return_on_cancel = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let return_on_cancel' = (fromIntegral . fromEnum) return_on_cancel+    result <- g_task_set_return_on_cancel _obj' return_on_cancel'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Task::set_source_tag+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source_tag", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source_tag", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_task_set_source_tag" g_task_set_source_tag :: +    Ptr Task ->                             -- _obj : TInterface "Gio" "Task"+    Ptr () ->                               -- source_tag : TBasicType TVoid+    IO ()+++taskSetSourceTag ::+    (MonadIO m, TaskK a) =>+    a ->                                    -- _obj+    Ptr () ->                               -- source_tag+    m ()+taskSetSourceTag _obj source_tag = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_task_set_source_tag _obj' source_tag+    touchManagedPtr _obj+    return ()++-- method Task::set_task_data+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "task_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "task_data_destroy", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "task_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "task_data_destroy", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_task_set_task_data" g_task_set_task_data :: +    Ptr Task ->                             -- _obj : TInterface "Gio" "Task"+    Ptr () ->                               -- task_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- task_data_destroy : TInterface "GLib" "DestroyNotify"+    IO ()+++taskSetTaskData ::+    (MonadIO m, TaskK a) =>+    a ->                                    -- _obj+    Maybe (Ptr ()) ->                       -- task_data+    Maybe (GLib.DestroyNotify) ->           -- task_data_destroy+    m ()+taskSetTaskData _obj task_data task_data_destroy = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeTask_data <- case task_data of+        Nothing -> return nullPtr+        Just jTask_data -> do+            return jTask_data+    ptrtask_data_destroy <- callocMem :: IO (Ptr (FunPtr GLib.DestroyNotifyC))+    maybeTask_data_destroy <- case task_data_destroy of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jTask_data_destroy -> do+            jTask_data_destroy' <- GLib.mkDestroyNotify (GLib.destroyNotifyWrapper (Just ptrtask_data_destroy) jTask_data_destroy)+            poke ptrtask_data_destroy jTask_data_destroy'+            return jTask_data_destroy'+    g_task_set_task_data _obj' maybeTask_data maybeTask_data_destroy+    touchManagedPtr _obj+    return ()++-- method Task::is_valid+-- method type : MemberFunction+-- Args : [Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source_object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source_object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_task_is_valid" g_task_is_valid :: +    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr GObject.Object ->                   -- source_object : TInterface "GObject" "Object"+    IO CInt+++taskIsValid ::+    (MonadIO m, AsyncResultK a, GObject.ObjectK b) =>+    a ->                                    -- result+    Maybe (b) ->                            -- source_object+    m Bool+taskIsValid result_ source_object = liftIO $ do+    let result_' = unsafeManagedPtrCastPtr result_+    maybeSource_object <- case source_object of+        Nothing -> return nullPtr+        Just jSource_object -> do+            let jSource_object' = unsafeManagedPtrCastPtr jSource_object+            return jSource_object'+    result <- g_task_is_valid result_' maybeSource_object+    let result' = (/= 0) result+    touchManagedPtr result_+    whenJust source_object touchManagedPtr+    return result'++-- method Task::report_error+-- method type : MemberFunction+-- Args : [Arg {argName = "source_object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 2, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source_tag", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "source_object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 2, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source_tag", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_task_report_error" g_task_report_error :: +    Ptr GObject.Object ->                   -- source_object : TInterface "GObject" "Object"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- callback_data : TBasicType TVoid+    Ptr () ->                               -- source_tag : TBasicType TVoid+    Ptr GError ->                           -- error : TError+    IO ()+++taskReportError ::+    (MonadIO m, GObject.ObjectK a) =>+    Maybe (a) ->                            -- source_object+    Maybe (AsyncReadyCallback) ->           -- callback+    Ptr () ->                               -- source_tag+    GError ->                               -- error+    m ()+taskReportError source_object callback source_tag error_ = liftIO $ do+    maybeSource_object <- case source_object of+        Nothing -> return nullPtr+        Just jSource_object -> do+            let jSource_object' = unsafeManagedPtrCastPtr jSource_object+            return jSource_object'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    error_' <- copyBoxed error_+    let callback_data = nullPtr+    g_task_report_error maybeSource_object maybeCallback callback_data source_tag error_'+    whenJust source_object touchManagedPtr+    touchManagedPtr error_+    return ()++
+ GI/Gio/Objects/Task.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gio.Objects.Task where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Task = Task (ForeignPtr Task)+instance GObject Task where+class GObject o => TaskK o+instance (GObject o, IsDescendantOf Task o) => TaskK o+data TaskCompletedPropertyInfo
+ GI/Gio/Objects/TcpConnection.hs view
@@ -0,0 +1,155 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.TcpConnection+    ( ++-- * Exported types+    TcpConnection(..)                       ,+    TcpConnectionK                          ,+    toTcpConnection                         ,+    noTcpConnection                         ,+++ -- * Methods+-- ** tcpConnectionGetGracefulDisconnect+    tcpConnectionGetGracefulDisconnect      ,+++-- ** tcpConnectionSetGracefulDisconnect+    tcpConnectionSetGracefulDisconnect      ,+++++ -- * Properties+-- ** GracefulDisconnect+    TcpConnectionGracefulDisconnectPropertyInfo,+    constructTcpConnectionGracefulDisconnect,+    getTcpConnectionGracefulDisconnect      ,+    setTcpConnectionGracefulDisconnect      ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype TcpConnection = TcpConnection (ForeignPtr TcpConnection)+foreign import ccall "g_tcp_connection_get_type"+    c_g_tcp_connection_get_type :: IO GType++type instance ParentTypes TcpConnection = TcpConnectionParentTypes+type TcpConnectionParentTypes = '[SocketConnection, IOStream, GObject.Object]++instance GObject TcpConnection where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_tcp_connection_get_type+    ++class GObject o => TcpConnectionK o+instance (GObject o, IsDescendantOf TcpConnection o) => TcpConnectionK o++toTcpConnection :: TcpConnectionK o => o -> IO TcpConnection+toTcpConnection = unsafeCastTo TcpConnection++noTcpConnection :: Maybe TcpConnection+noTcpConnection = Nothing++-- VVV Prop "graceful-disconnect"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getTcpConnectionGracefulDisconnect :: (MonadIO m, TcpConnectionK o) => o -> m Bool+getTcpConnectionGracefulDisconnect obj = liftIO $ getObjectPropertyBool obj "graceful-disconnect"++setTcpConnectionGracefulDisconnect :: (MonadIO m, TcpConnectionK o) => o -> Bool -> m ()+setTcpConnectionGracefulDisconnect obj val = liftIO $ setObjectPropertyBool obj "graceful-disconnect" val++constructTcpConnectionGracefulDisconnect :: Bool -> IO ([Char], GValue)+constructTcpConnectionGracefulDisconnect val = constructObjectPropertyBool "graceful-disconnect" val++data TcpConnectionGracefulDisconnectPropertyInfo+instance AttrInfo TcpConnectionGracefulDisconnectPropertyInfo where+    type AttrAllowedOps TcpConnectionGracefulDisconnectPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TcpConnectionGracefulDisconnectPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint TcpConnectionGracefulDisconnectPropertyInfo = TcpConnectionK+    type AttrGetType TcpConnectionGracefulDisconnectPropertyInfo = Bool+    type AttrLabel TcpConnectionGracefulDisconnectPropertyInfo = "TcpConnection::graceful-disconnect"+    attrGet _ = getTcpConnectionGracefulDisconnect+    attrSet _ = setTcpConnectionGracefulDisconnect+    attrConstruct _ = constructTcpConnectionGracefulDisconnect++type instance AttributeList TcpConnection = TcpConnectionAttributeList+type TcpConnectionAttributeList = ('[ '("closed", IOStreamClosedPropertyInfo), '("graceful-disconnect", TcpConnectionGracefulDisconnectPropertyInfo), '("input-stream", IOStreamInputStreamPropertyInfo), '("output-stream", IOStreamOutputStreamPropertyInfo), '("socket", SocketConnectionSocketPropertyInfo)] :: [(Symbol, *)])++type instance SignalList TcpConnection = TcpConnectionSignalList+type TcpConnectionSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method TcpConnection::get_graceful_disconnect+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TcpConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TcpConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_tcp_connection_get_graceful_disconnect" g_tcp_connection_get_graceful_disconnect :: +    Ptr TcpConnection ->                    -- _obj : TInterface "Gio" "TcpConnection"+    IO CInt+++tcpConnectionGetGracefulDisconnect ::+    (MonadIO m, TcpConnectionK a) =>+    a ->                                    -- _obj+    m Bool+tcpConnectionGetGracefulDisconnect _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_tcp_connection_get_graceful_disconnect _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method TcpConnection::set_graceful_disconnect+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TcpConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "graceful_disconnect", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TcpConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "graceful_disconnect", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_tcp_connection_set_graceful_disconnect" g_tcp_connection_set_graceful_disconnect :: +    Ptr TcpConnection ->                    -- _obj : TInterface "Gio" "TcpConnection"+    CInt ->                                 -- graceful_disconnect : TBasicType TBoolean+    IO ()+++tcpConnectionSetGracefulDisconnect ::+    (MonadIO m, TcpConnectionK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- graceful_disconnect+    m ()+tcpConnectionSetGracefulDisconnect _obj graceful_disconnect = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let graceful_disconnect' = (fromIntegral . fromEnum) graceful_disconnect+    g_tcp_connection_set_graceful_disconnect _obj' graceful_disconnect'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Objects/TcpConnection.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gio.Objects.TcpConnection where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype TcpConnection = TcpConnection (ForeignPtr TcpConnection)+instance GObject TcpConnection where+class GObject o => TcpConnectionK o+instance (GObject o, IsDescendantOf TcpConnection o) => TcpConnectionK o+data TcpConnectionGracefulDisconnectPropertyInfo
+ GI/Gio/Objects/TcpWrapperConnection.hs view
@@ -0,0 +1,155 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.TcpWrapperConnection+    ( ++-- * Exported types+    TcpWrapperConnection(..)                ,+    TcpWrapperConnectionK                   ,+    toTcpWrapperConnection                  ,+    noTcpWrapperConnection                  ,+++ -- * Methods+-- ** tcpWrapperConnectionGetBaseIoStream+    tcpWrapperConnectionGetBaseIoStream     ,+++-- ** tcpWrapperConnectionNew+    tcpWrapperConnectionNew                 ,+++++ -- * Properties+-- ** BaseIoStream+    TcpWrapperConnectionBaseIoStreamPropertyInfo,+    constructTcpWrapperConnectionBaseIoStream,+    getTcpWrapperConnectionBaseIoStream     ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype TcpWrapperConnection = TcpWrapperConnection (ForeignPtr TcpWrapperConnection)+foreign import ccall "g_tcp_wrapper_connection_get_type"+    c_g_tcp_wrapper_connection_get_type :: IO GType++type instance ParentTypes TcpWrapperConnection = TcpWrapperConnectionParentTypes+type TcpWrapperConnectionParentTypes = '[TcpConnection, SocketConnection, IOStream, GObject.Object]++instance GObject TcpWrapperConnection where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_tcp_wrapper_connection_get_type+    ++class GObject o => TcpWrapperConnectionK o+instance (GObject o, IsDescendantOf TcpWrapperConnection o) => TcpWrapperConnectionK o++toTcpWrapperConnection :: TcpWrapperConnectionK o => o -> IO TcpWrapperConnection+toTcpWrapperConnection = unsafeCastTo TcpWrapperConnection++noTcpWrapperConnection :: Maybe TcpWrapperConnection+noTcpWrapperConnection = Nothing++-- VVV Prop "base-io-stream"+   -- Type: TInterface "Gio" "IOStream"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getTcpWrapperConnectionBaseIoStream :: (MonadIO m, TcpWrapperConnectionK o) => o -> m IOStream+getTcpWrapperConnectionBaseIoStream obj = liftIO $ getObjectPropertyObject obj "base-io-stream" IOStream++constructTcpWrapperConnectionBaseIoStream :: (IOStreamK a) => a -> IO ([Char], GValue)+constructTcpWrapperConnectionBaseIoStream val = constructObjectPropertyObject "base-io-stream" val++data TcpWrapperConnectionBaseIoStreamPropertyInfo+instance AttrInfo TcpWrapperConnectionBaseIoStreamPropertyInfo where+    type AttrAllowedOps TcpWrapperConnectionBaseIoStreamPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TcpWrapperConnectionBaseIoStreamPropertyInfo = IOStreamK+    type AttrBaseTypeConstraint TcpWrapperConnectionBaseIoStreamPropertyInfo = TcpWrapperConnectionK+    type AttrGetType TcpWrapperConnectionBaseIoStreamPropertyInfo = IOStream+    type AttrLabel TcpWrapperConnectionBaseIoStreamPropertyInfo = "TcpWrapperConnection::base-io-stream"+    attrGet _ = getTcpWrapperConnectionBaseIoStream+    attrSet _ = undefined+    attrConstruct _ = constructTcpWrapperConnectionBaseIoStream++type instance AttributeList TcpWrapperConnection = TcpWrapperConnectionAttributeList+type TcpWrapperConnectionAttributeList = ('[ '("base-io-stream", TcpWrapperConnectionBaseIoStreamPropertyInfo), '("closed", IOStreamClosedPropertyInfo), '("graceful-disconnect", TcpConnectionGracefulDisconnectPropertyInfo), '("input-stream", IOStreamInputStreamPropertyInfo), '("output-stream", IOStreamOutputStreamPropertyInfo), '("socket", SocketConnectionSocketPropertyInfo)] :: [(Symbol, *)])++type instance SignalList TcpWrapperConnection = TcpWrapperConnectionSignalList+type TcpWrapperConnectionSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method TcpWrapperConnection::new+-- method type : Constructor+-- Args : [Arg {argName = "base_io_stream", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "socket", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "base_io_stream", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "socket", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TcpWrapperConnection"+-- throws : False+-- Skip return : False++foreign import ccall "g_tcp_wrapper_connection_new" g_tcp_wrapper_connection_new :: +    Ptr IOStream ->                         -- base_io_stream : TInterface "Gio" "IOStream"+    Ptr Socket ->                           -- socket : TInterface "Gio" "Socket"+    IO (Ptr TcpWrapperConnection)+++tcpWrapperConnectionNew ::+    (MonadIO m, IOStreamK a, SocketK b) =>+    a ->                                    -- base_io_stream+    b ->                                    -- socket+    m TcpWrapperConnection+tcpWrapperConnectionNew base_io_stream socket = liftIO $ do+    let base_io_stream' = unsafeManagedPtrCastPtr base_io_stream+    let socket' = unsafeManagedPtrCastPtr socket+    result <- g_tcp_wrapper_connection_new base_io_stream' socket'+    checkUnexpectedReturnNULL "g_tcp_wrapper_connection_new" result+    result' <- (wrapObject TcpWrapperConnection) result+    touchManagedPtr base_io_stream+    touchManagedPtr socket+    return result'++-- method TcpWrapperConnection::get_base_io_stream+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TcpWrapperConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TcpWrapperConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "IOStream"+-- throws : False+-- Skip return : False++foreign import ccall "g_tcp_wrapper_connection_get_base_io_stream" g_tcp_wrapper_connection_get_base_io_stream :: +    Ptr TcpWrapperConnection ->             -- _obj : TInterface "Gio" "TcpWrapperConnection"+    IO (Ptr IOStream)+++tcpWrapperConnectionGetBaseIoStream ::+    (MonadIO m, TcpWrapperConnectionK a) =>+    a ->                                    -- _obj+    m IOStream+tcpWrapperConnectionGetBaseIoStream _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_tcp_wrapper_connection_get_base_io_stream _obj'+    checkUnexpectedReturnNULL "g_tcp_wrapper_connection_get_base_io_stream" result+    result' <- (newObject IOStream) result+    touchManagedPtr _obj+    return result'++
+ GI/Gio/Objects/TcpWrapperConnection.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gio.Objects.TcpWrapperConnection where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype TcpWrapperConnection = TcpWrapperConnection (ForeignPtr TcpWrapperConnection)+instance GObject TcpWrapperConnection where+class GObject o => TcpWrapperConnectionK o+instance (GObject o, IsDescendantOf TcpWrapperConnection o) => TcpWrapperConnectionK o+data TcpWrapperConnectionBaseIoStreamPropertyInfo
+ GI/Gio/Objects/TestDBus.hs view
@@ -0,0 +1,319 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.TestDBus+    ( ++-- * Exported types+    TestDBus(..)                            ,+    TestDBusK                               ,+    toTestDBus                              ,+    noTestDBus                              ,+++ -- * Methods+-- ** testDBusAddServiceDir+    testDBusAddServiceDir                   ,+++-- ** testDBusDown+    testDBusDown                            ,+++-- ** testDBusGetBusAddress+    testDBusGetBusAddress                   ,+++-- ** testDBusGetFlags+    testDBusGetFlags                        ,+++-- ** testDBusNew+    testDBusNew                             ,+++-- ** testDBusStop+    testDBusStop                            ,+++-- ** testDBusUnset+    testDBusUnset                           ,+++-- ** testDBusUp+    testDBusUp                              ,+++++ -- * Properties+-- ** Flags+    TestDBusFlagsPropertyInfo               ,+    constructTestDBusFlags                  ,+    getTestDBusFlags                        ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype TestDBus = TestDBus (ForeignPtr TestDBus)+foreign import ccall "g_test_dbus_get_type"+    c_g_test_dbus_get_type :: IO GType++type instance ParentTypes TestDBus = TestDBusParentTypes+type TestDBusParentTypes = '[GObject.Object]++instance GObject TestDBus where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_test_dbus_get_type+    ++class GObject o => TestDBusK o+instance (GObject o, IsDescendantOf TestDBus o) => TestDBusK o++toTestDBus :: TestDBusK o => o -> IO TestDBus+toTestDBus = unsafeCastTo TestDBus++noTestDBus :: Maybe TestDBus+noTestDBus = Nothing++-- VVV Prop "flags"+   -- Type: TInterface "Gio" "TestDBusFlags"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getTestDBusFlags :: (MonadIO m, TestDBusK o) => o -> m [TestDBusFlags]+getTestDBusFlags obj = liftIO $ getObjectPropertyFlags obj "flags"++constructTestDBusFlags :: [TestDBusFlags] -> IO ([Char], GValue)+constructTestDBusFlags val = constructObjectPropertyFlags "flags" val++data TestDBusFlagsPropertyInfo+instance AttrInfo TestDBusFlagsPropertyInfo where+    type AttrAllowedOps TestDBusFlagsPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TestDBusFlagsPropertyInfo = (~) [TestDBusFlags]+    type AttrBaseTypeConstraint TestDBusFlagsPropertyInfo = TestDBusK+    type AttrGetType TestDBusFlagsPropertyInfo = [TestDBusFlags]+    type AttrLabel TestDBusFlagsPropertyInfo = "TestDBus::flags"+    attrGet _ = getTestDBusFlags+    attrSet _ = undefined+    attrConstruct _ = constructTestDBusFlags++type instance AttributeList TestDBus = TestDBusAttributeList+type TestDBusAttributeList = ('[ '("flags", TestDBusFlagsPropertyInfo)] :: [(Symbol, *)])++type instance SignalList TestDBus = TestDBusSignalList+type TestDBusSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method TestDBus::new+-- method type : Constructor+-- Args : [Arg {argName = "flags", argType = TInterface "Gio" "TestDBusFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "flags", argType = TInterface "Gio" "TestDBusFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TestDBus"+-- throws : False+-- Skip return : False++foreign import ccall "g_test_dbus_new" g_test_dbus_new :: +    CUInt ->                                -- flags : TInterface "Gio" "TestDBusFlags"+    IO (Ptr TestDBus)+++testDBusNew ::+    (MonadIO m) =>+    [TestDBusFlags] ->                      -- flags+    m TestDBus+testDBusNew flags = liftIO $ do+    let flags' = gflagsToWord flags+    result <- g_test_dbus_new flags'+    checkUnexpectedReturnNULL "g_test_dbus_new" result+    result' <- (wrapObject TestDBus) result+    return result'++-- method TestDBus::add_service_dir+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TestDBus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TestDBus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_test_dbus_add_service_dir" g_test_dbus_add_service_dir :: +    Ptr TestDBus ->                         -- _obj : TInterface "Gio" "TestDBus"+    CString ->                              -- path : TBasicType TUTF8+    IO ()+++testDBusAddServiceDir ::+    (MonadIO m, TestDBusK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- path+    m ()+testDBusAddServiceDir _obj path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    path' <- textToCString path+    g_test_dbus_add_service_dir _obj' path'+    touchManagedPtr _obj+    freeMem path'+    return ()++-- method TestDBus::down+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TestDBus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TestDBus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_test_dbus_down" g_test_dbus_down :: +    Ptr TestDBus ->                         -- _obj : TInterface "Gio" "TestDBus"+    IO ()+++testDBusDown ::+    (MonadIO m, TestDBusK a) =>+    a ->                                    -- _obj+    m ()+testDBusDown _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_test_dbus_down _obj'+    touchManagedPtr _obj+    return ()++-- method TestDBus::get_bus_address+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TestDBus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TestDBus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_test_dbus_get_bus_address" g_test_dbus_get_bus_address :: +    Ptr TestDBus ->                         -- _obj : TInterface "Gio" "TestDBus"+    IO CString+++testDBusGetBusAddress ::+    (MonadIO m, TestDBusK a) =>+    a ->                                    -- _obj+    m T.Text+testDBusGetBusAddress _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_test_dbus_get_bus_address _obj'+    checkUnexpectedReturnNULL "g_test_dbus_get_bus_address" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method TestDBus::get_flags+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TestDBus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TestDBus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TestDBusFlags"+-- throws : False+-- Skip return : False++foreign import ccall "g_test_dbus_get_flags" g_test_dbus_get_flags :: +    Ptr TestDBus ->                         -- _obj : TInterface "Gio" "TestDBus"+    IO CUInt+++testDBusGetFlags ::+    (MonadIO m, TestDBusK a) =>+    a ->                                    -- _obj+    m [TestDBusFlags]+testDBusGetFlags _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_test_dbus_get_flags _obj'+    let result' = wordToGFlags result+    touchManagedPtr _obj+    return result'++-- method TestDBus::stop+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TestDBus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TestDBus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_test_dbus_stop" g_test_dbus_stop :: +    Ptr TestDBus ->                         -- _obj : TInterface "Gio" "TestDBus"+    IO ()+++testDBusStop ::+    (MonadIO m, TestDBusK a) =>+    a ->                                    -- _obj+    m ()+testDBusStop _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_test_dbus_stop _obj'+    touchManagedPtr _obj+    return ()++-- method TestDBus::up+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TestDBus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TestDBus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_test_dbus_up" g_test_dbus_up :: +    Ptr TestDBus ->                         -- _obj : TInterface "Gio" "TestDBus"+    IO ()+++testDBusUp ::+    (MonadIO m, TestDBusK a) =>+    a ->                                    -- _obj+    m ()+testDBusUp _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_test_dbus_up _obj'+    touchManagedPtr _obj+    return ()++-- method TestDBus::unset+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_test_dbus_unset" g_test_dbus_unset :: +    IO ()+++testDBusUnset ::+    (MonadIO m) =>+    m ()+testDBusUnset  = liftIO $ do+    g_test_dbus_unset+    return ()++
+ GI/Gio/Objects/TestDBus.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gio.Objects.TestDBus where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype TestDBus = TestDBus (ForeignPtr TestDBus)+instance GObject TestDBus where+class GObject o => TestDBusK o+instance (GObject o, IsDescendantOf TestDBus o) => TestDBusK o+data TestDBusFlagsPropertyInfo
+ GI/Gio/Objects/ThemedIcon.hs view
@@ -0,0 +1,328 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.ThemedIcon+    ( ++-- * Exported types+    ThemedIcon(..)                          ,+    ThemedIconK                             ,+    toThemedIcon                            ,+    noThemedIcon                            ,+++ -- * Methods+-- ** themedIconAppendName+    themedIconAppendName                    ,+++-- ** themedIconGetNames+    themedIconGetNames                      ,+++-- ** themedIconNew+    themedIconNew                           ,+++-- ** themedIconNewFromNames+    themedIconNewFromNames                  ,+++-- ** themedIconNewWithDefaultFallbacks+    themedIconNewWithDefaultFallbacks       ,+++-- ** themedIconPrependName+    themedIconPrependName                   ,+++++ -- * Properties+-- ** Name+    ThemedIconNamePropertyInfo              ,+    constructThemedIconName                 ,+++-- ** Names+    ThemedIconNamesPropertyInfo             ,+    constructThemedIconNames                ,+    getThemedIconNames                      ,+++-- ** UseDefaultFallbacks+    ThemedIconUseDefaultFallbacksPropertyInfo,+    constructThemedIconUseDefaultFallbacks  ,+    getThemedIconUseDefaultFallbacks        ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype ThemedIcon = ThemedIcon (ForeignPtr ThemedIcon)+foreign import ccall "g_themed_icon_get_type"+    c_g_themed_icon_get_type :: IO GType++type instance ParentTypes ThemedIcon = ThemedIconParentTypes+type ThemedIconParentTypes = '[GObject.Object, Icon]++instance GObject ThemedIcon where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_themed_icon_get_type+    ++class GObject o => ThemedIconK o+instance (GObject o, IsDescendantOf ThemedIcon o) => ThemedIconK o++toThemedIcon :: ThemedIconK o => o -> IO ThemedIcon+toThemedIcon = unsafeCastTo ThemedIcon++noThemedIcon :: Maybe ThemedIcon+noThemedIcon = Nothing++-- VVV Prop "name"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyWritable,PropertyConstructOnly]++constructThemedIconName :: T.Text -> IO ([Char], GValue)+constructThemedIconName val = constructObjectPropertyString "name" val++data ThemedIconNamePropertyInfo+instance AttrInfo ThemedIconNamePropertyInfo where+    type AttrAllowedOps ThemedIconNamePropertyInfo = '[ 'AttrConstruct]+    type AttrSetTypeConstraint ThemedIconNamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ThemedIconNamePropertyInfo = ThemedIconK+    type AttrGetType ThemedIconNamePropertyInfo = ()+    type AttrLabel ThemedIconNamePropertyInfo = "ThemedIcon::name"+    attrGet _ = undefined+    attrSet _ = undefined+    attrConstruct _ = constructThemedIconName++-- VVV Prop "names"+   -- Type: TCArray True (-1) (-1) (TBasicType TUTF8)+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getThemedIconNames :: (MonadIO m, ThemedIconK o) => o -> m [T.Text]+getThemedIconNames obj = liftIO $ getObjectPropertyStringArray obj "names"++constructThemedIconNames :: [T.Text] -> IO ([Char], GValue)+constructThemedIconNames val = constructObjectPropertyStringArray "names" val++data ThemedIconNamesPropertyInfo+instance AttrInfo ThemedIconNamesPropertyInfo where+    type AttrAllowedOps ThemedIconNamesPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ThemedIconNamesPropertyInfo = (~) [T.Text]+    type AttrBaseTypeConstraint ThemedIconNamesPropertyInfo = ThemedIconK+    type AttrGetType ThemedIconNamesPropertyInfo = [T.Text]+    type AttrLabel ThemedIconNamesPropertyInfo = "ThemedIcon::names"+    attrGet _ = getThemedIconNames+    attrSet _ = undefined+    attrConstruct _ = constructThemedIconNames++-- VVV Prop "use-default-fallbacks"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getThemedIconUseDefaultFallbacks :: (MonadIO m, ThemedIconK o) => o -> m Bool+getThemedIconUseDefaultFallbacks obj = liftIO $ getObjectPropertyBool obj "use-default-fallbacks"++constructThemedIconUseDefaultFallbacks :: Bool -> IO ([Char], GValue)+constructThemedIconUseDefaultFallbacks val = constructObjectPropertyBool "use-default-fallbacks" val++data ThemedIconUseDefaultFallbacksPropertyInfo+instance AttrInfo ThemedIconUseDefaultFallbacksPropertyInfo where+    type AttrAllowedOps ThemedIconUseDefaultFallbacksPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ThemedIconUseDefaultFallbacksPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ThemedIconUseDefaultFallbacksPropertyInfo = ThemedIconK+    type AttrGetType ThemedIconUseDefaultFallbacksPropertyInfo = Bool+    type AttrLabel ThemedIconUseDefaultFallbacksPropertyInfo = "ThemedIcon::use-default-fallbacks"+    attrGet _ = getThemedIconUseDefaultFallbacks+    attrSet _ = undefined+    attrConstruct _ = constructThemedIconUseDefaultFallbacks++type instance AttributeList ThemedIcon = ThemedIconAttributeList+type ThemedIconAttributeList = ('[ '("name", ThemedIconNamePropertyInfo), '("names", ThemedIconNamesPropertyInfo), '("use-default-fallbacks", ThemedIconUseDefaultFallbacksPropertyInfo)] :: [(Symbol, *)])++type instance SignalList ThemedIcon = ThemedIconSignalList+type ThemedIconSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method ThemedIcon::new+-- method type : Constructor+-- Args : [Arg {argName = "iconname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "iconname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "ThemedIcon"+-- throws : False+-- Skip return : False++foreign import ccall "g_themed_icon_new" g_themed_icon_new :: +    CString ->                              -- iconname : TBasicType TUTF8+    IO (Ptr ThemedIcon)+++themedIconNew ::+    (MonadIO m) =>+    T.Text ->                               -- iconname+    m ThemedIcon+themedIconNew iconname = liftIO $ do+    iconname' <- textToCString iconname+    result <- g_themed_icon_new iconname'+    checkUnexpectedReturnNULL "g_themed_icon_new" result+    result' <- (wrapObject ThemedIcon) result+    freeMem iconname'+    return result'++-- method ThemedIcon::new_from_names+-- method type : Constructor+-- Args : [Arg {argName = "iconnames", argType = TCArray False (-1) 1 (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "len", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "len", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "iconnames", argType = TCArray False (-1) 1 (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "ThemedIcon"+-- throws : False+-- Skip return : False++foreign import ccall "g_themed_icon_new_from_names" g_themed_icon_new_from_names :: +    Ptr CString ->                          -- iconnames : TCArray False (-1) 1 (TBasicType TUTF8)+    Int32 ->                                -- len : TBasicType TInt32+    IO (Ptr ThemedIcon)+++themedIconNewFromNames ::+    (MonadIO m) =>+    [T.Text] ->                             -- iconnames+    m ThemedIcon+themedIconNewFromNames iconnames = liftIO $ do+    let len = fromIntegral $ length iconnames+    iconnames' <- packUTF8CArray iconnames+    result <- g_themed_icon_new_from_names iconnames' len+    checkUnexpectedReturnNULL "g_themed_icon_new_from_names" result+    result' <- (wrapObject ThemedIcon) result+    (mapCArrayWithLength len) freeMem iconnames'+    freeMem iconnames'+    return result'++-- method ThemedIcon::new_with_default_fallbacks+-- method type : Constructor+-- Args : [Arg {argName = "iconname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "iconname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "ThemedIcon"+-- throws : False+-- Skip return : False++foreign import ccall "g_themed_icon_new_with_default_fallbacks" g_themed_icon_new_with_default_fallbacks :: +    CString ->                              -- iconname : TBasicType TUTF8+    IO (Ptr ThemedIcon)+++themedIconNewWithDefaultFallbacks ::+    (MonadIO m) =>+    T.Text ->                               -- iconname+    m ThemedIcon+themedIconNewWithDefaultFallbacks iconname = liftIO $ do+    iconname' <- textToCString iconname+    result <- g_themed_icon_new_with_default_fallbacks iconname'+    checkUnexpectedReturnNULL "g_themed_icon_new_with_default_fallbacks" result+    result' <- (wrapObject ThemedIcon) result+    freeMem iconname'+    return result'++-- method ThemedIcon::append_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ThemedIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iconname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ThemedIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iconname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_themed_icon_append_name" g_themed_icon_append_name :: +    Ptr ThemedIcon ->                       -- _obj : TInterface "Gio" "ThemedIcon"+    CString ->                              -- iconname : TBasicType TUTF8+    IO ()+++themedIconAppendName ::+    (MonadIO m, ThemedIconK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- iconname+    m ()+themedIconAppendName _obj iconname = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    iconname' <- textToCString iconname+    g_themed_icon_append_name _obj' iconname'+    touchManagedPtr _obj+    freeMem iconname'+    return ()++-- method ThemedIcon::get_names+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ThemedIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ThemedIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_themed_icon_get_names" g_themed_icon_get_names :: +    Ptr ThemedIcon ->                       -- _obj : TInterface "Gio" "ThemedIcon"+    IO (Ptr CString)+++themedIconGetNames ::+    (MonadIO m, ThemedIconK a) =>+    a ->                                    -- _obj+    m [T.Text]+themedIconGetNames _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_themed_icon_get_names _obj'+    checkUnexpectedReturnNULL "g_themed_icon_get_names" result+    result' <- unpackZeroTerminatedUTF8CArray result+    touchManagedPtr _obj+    return result'++-- method ThemedIcon::prepend_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ThemedIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iconname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ThemedIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iconname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_themed_icon_prepend_name" g_themed_icon_prepend_name :: +    Ptr ThemedIcon ->                       -- _obj : TInterface "Gio" "ThemedIcon"+    CString ->                              -- iconname : TBasicType TUTF8+    IO ()+++themedIconPrependName ::+    (MonadIO m, ThemedIconK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- iconname+    m ()+themedIconPrependName _obj iconname = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    iconname' <- textToCString iconname+    g_themed_icon_prepend_name _obj' iconname'+    touchManagedPtr _obj+    freeMem iconname'+    return ()++
+ GI/Gio/Objects/ThemedIcon.hs-boot view
@@ -0,0 +1,16 @@+module GI.Gio.Objects.ThemedIcon where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype ThemedIcon = ThemedIcon (ForeignPtr ThemedIcon)+instance GObject ThemedIcon where+class GObject o => ThemedIconK o+instance (GObject o, IsDescendantOf ThemedIcon o) => ThemedIconK o+data ThemedIconNamePropertyInfo+data ThemedIconNamesPropertyInfo+data ThemedIconUseDefaultFallbacksPropertyInfo
+ GI/Gio/Objects/ThreadedSocketService.hs view
@@ -0,0 +1,187 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.ThreadedSocketService+    ( ++-- * Exported types+    ThreadedSocketService(..)               ,+    ThreadedSocketServiceK                  ,+    toThreadedSocketService                 ,+    noThreadedSocketService                 ,+++ -- * Methods+-- ** threadedSocketServiceNew+    threadedSocketServiceNew                ,+++++ -- * Properties+-- ** MaxThreads+    ThreadedSocketServiceMaxThreadsPropertyInfo,+    constructThreadedSocketServiceMaxThreads,+    getThreadedSocketServiceMaxThreads      ,+++++ -- * Signals+-- ** Run+    ThreadedSocketServiceRunCallback        ,+    ThreadedSocketServiceRunCallbackC       ,+    ThreadedSocketServiceRunSignalInfo      ,+    afterThreadedSocketServiceRun           ,+    mkThreadedSocketServiceRunCallback      ,+    noThreadedSocketServiceRunCallback      ,+    onThreadedSocketServiceRun              ,+    threadedSocketServiceRunCallbackWrapper ,+    threadedSocketServiceRunClosure         ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype ThreadedSocketService = ThreadedSocketService (ForeignPtr ThreadedSocketService)+foreign import ccall "g_threaded_socket_service_get_type"+    c_g_threaded_socket_service_get_type :: IO GType++type instance ParentTypes ThreadedSocketService = ThreadedSocketServiceParentTypes+type ThreadedSocketServiceParentTypes = '[SocketService, SocketListener, GObject.Object]++instance GObject ThreadedSocketService where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_threaded_socket_service_get_type+    ++class GObject o => ThreadedSocketServiceK o+instance (GObject o, IsDescendantOf ThreadedSocketService o) => ThreadedSocketServiceK o++toThreadedSocketService :: ThreadedSocketServiceK o => o -> IO ThreadedSocketService+toThreadedSocketService = unsafeCastTo ThreadedSocketService++noThreadedSocketService :: Maybe ThreadedSocketService+noThreadedSocketService = Nothing++-- signal ThreadedSocketService::run+type ThreadedSocketServiceRunCallback =+    SocketConnection ->+    GObject.Object ->+    IO Bool++noThreadedSocketServiceRunCallback :: Maybe ThreadedSocketServiceRunCallback+noThreadedSocketServiceRunCallback = Nothing++type ThreadedSocketServiceRunCallbackC =+    Ptr () ->                               -- object+    Ptr SocketConnection ->+    Ptr GObject.Object ->+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkThreadedSocketServiceRunCallback :: ThreadedSocketServiceRunCallbackC -> IO (FunPtr ThreadedSocketServiceRunCallbackC)++threadedSocketServiceRunClosure :: ThreadedSocketServiceRunCallback -> IO Closure+threadedSocketServiceRunClosure cb = newCClosure =<< mkThreadedSocketServiceRunCallback wrapped+    where wrapped = threadedSocketServiceRunCallbackWrapper cb++threadedSocketServiceRunCallbackWrapper ::+    ThreadedSocketServiceRunCallback ->+    Ptr () ->+    Ptr SocketConnection ->+    Ptr GObject.Object ->+    Ptr () ->+    IO CInt+threadedSocketServiceRunCallbackWrapper _cb _ connection source_object _ = do+    connection' <- (newObject SocketConnection) connection+    source_object' <- (newObject GObject.Object) source_object+    result <- _cb  connection' source_object'+    let result' = (fromIntegral . fromEnum) result+    return result'++onThreadedSocketServiceRun :: (GObject a, MonadIO m) => a -> ThreadedSocketServiceRunCallback -> m SignalHandlerId+onThreadedSocketServiceRun obj cb = liftIO $ connectThreadedSocketServiceRun obj cb SignalConnectBefore+afterThreadedSocketServiceRun :: (GObject a, MonadIO m) => a -> ThreadedSocketServiceRunCallback -> m SignalHandlerId+afterThreadedSocketServiceRun obj cb = connectThreadedSocketServiceRun obj cb SignalConnectAfter++connectThreadedSocketServiceRun :: (GObject a, MonadIO m) =>+                                   a -> ThreadedSocketServiceRunCallback -> SignalConnectMode -> m SignalHandlerId+connectThreadedSocketServiceRun obj cb after = liftIO $ do+    cb' <- mkThreadedSocketServiceRunCallback (threadedSocketServiceRunCallbackWrapper cb)+    connectSignalFunPtr obj "run" cb' after++-- VVV Prop "max-threads"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getThreadedSocketServiceMaxThreads :: (MonadIO m, ThreadedSocketServiceK o) => o -> m Int32+getThreadedSocketServiceMaxThreads obj = liftIO $ getObjectPropertyCInt obj "max-threads"++constructThreadedSocketServiceMaxThreads :: Int32 -> IO ([Char], GValue)+constructThreadedSocketServiceMaxThreads val = constructObjectPropertyCInt "max-threads" val++data ThreadedSocketServiceMaxThreadsPropertyInfo+instance AttrInfo ThreadedSocketServiceMaxThreadsPropertyInfo where+    type AttrAllowedOps ThreadedSocketServiceMaxThreadsPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ThreadedSocketServiceMaxThreadsPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint ThreadedSocketServiceMaxThreadsPropertyInfo = ThreadedSocketServiceK+    type AttrGetType ThreadedSocketServiceMaxThreadsPropertyInfo = Int32+    type AttrLabel ThreadedSocketServiceMaxThreadsPropertyInfo = "ThreadedSocketService::max-threads"+    attrGet _ = getThreadedSocketServiceMaxThreads+    attrSet _ = undefined+    attrConstruct _ = constructThreadedSocketServiceMaxThreads++type instance AttributeList ThreadedSocketService = ThreadedSocketServiceAttributeList+type ThreadedSocketServiceAttributeList = ('[ '("active", SocketServiceActivePropertyInfo), '("listen-backlog", SocketListenerListenBacklogPropertyInfo), '("max-threads", ThreadedSocketServiceMaxThreadsPropertyInfo)] :: [(Symbol, *)])++data ThreadedSocketServiceRunSignalInfo+instance SignalInfo ThreadedSocketServiceRunSignalInfo where+    type HaskellCallbackType ThreadedSocketServiceRunSignalInfo = ThreadedSocketServiceRunCallback+    connectSignal _ = connectThreadedSocketServiceRun++type instance SignalList ThreadedSocketService = ThreadedSocketServiceSignalList+type ThreadedSocketServiceSignalList = ('[ '("event", SocketListenerEventSignalInfo), '("incoming", SocketServiceIncomingSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("run", ThreadedSocketServiceRunSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method ThreadedSocketService::new+-- method type : Constructor+-- Args : [Arg {argName = "max_threads", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "max_threads", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "ThreadedSocketService"+-- throws : False+-- Skip return : False++foreign import ccall "g_threaded_socket_service_new" g_threaded_socket_service_new :: +    Int32 ->                                -- max_threads : TBasicType TInt32+    IO (Ptr ThreadedSocketService)+++threadedSocketServiceNew ::+    (MonadIO m) =>+    Int32 ->                                -- max_threads+    m ThreadedSocketService+threadedSocketServiceNew max_threads = liftIO $ do+    result <- g_threaded_socket_service_new max_threads+    checkUnexpectedReturnNULL "g_threaded_socket_service_new" result+    result' <- (wrapObject ThreadedSocketService) result+    return result'++
+ GI/Gio/Objects/ThreadedSocketService.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gio.Objects.ThreadedSocketService where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype ThreadedSocketService = ThreadedSocketService (ForeignPtr ThreadedSocketService)+instance GObject ThreadedSocketService where+class GObject o => ThreadedSocketServiceK o+instance (GObject o, IsDescendantOf ThreadedSocketService o) => ThreadedSocketServiceK o+data ThreadedSocketServiceMaxThreadsPropertyInfo+data ThreadedSocketServiceRunSignalInfo
+ GI/Gio/Objects/TlsCertificate.hs view
@@ -0,0 +1,448 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.TlsCertificate+    ( ++-- * Exported types+    TlsCertificate(..)                      ,+    TlsCertificateK                         ,+    toTlsCertificate                        ,+    noTlsCertificate                        ,+++ -- * Methods+-- ** tlsCertificateGetIssuer+    tlsCertificateGetIssuer                 ,+++-- ** tlsCertificateIsSame+    tlsCertificateIsSame                    ,+++-- ** tlsCertificateListNewFromFile+    tlsCertificateListNewFromFile           ,+++-- ** tlsCertificateNewFromFile+    tlsCertificateNewFromFile               ,+++-- ** tlsCertificateNewFromFiles+    tlsCertificateNewFromFiles              ,+++-- ** tlsCertificateNewFromPem+    tlsCertificateNewFromPem                ,+++-- ** tlsCertificateVerify+    tlsCertificateVerify                    ,+++++ -- * Properties+-- ** Certificate+    TlsCertificateCertificatePropertyInfo   ,+    constructTlsCertificateCertificate      ,+    getTlsCertificateCertificate            ,+++-- ** CertificatePem+    TlsCertificateCertificatePemPropertyInfo,+    constructTlsCertificateCertificatePem   ,+    getTlsCertificateCertificatePem         ,+++-- ** Issuer+    TlsCertificateIssuerPropertyInfo        ,+    constructTlsCertificateIssuer           ,+    getTlsCertificateIssuer                 ,+++-- ** PrivateKey+    TlsCertificatePrivateKeyPropertyInfo    ,+    constructTlsCertificatePrivateKey       ,+++-- ** PrivateKeyPem+    TlsCertificatePrivateKeyPemPropertyInfo ,+    constructTlsCertificatePrivateKeyPem    ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype TlsCertificate = TlsCertificate (ForeignPtr TlsCertificate)+foreign import ccall "g_tls_certificate_get_type"+    c_g_tls_certificate_get_type :: IO GType++type instance ParentTypes TlsCertificate = TlsCertificateParentTypes+type TlsCertificateParentTypes = '[GObject.Object]++instance GObject TlsCertificate where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_tls_certificate_get_type+    ++class GObject o => TlsCertificateK o+instance (GObject o, IsDescendantOf TlsCertificate o) => TlsCertificateK o++toTlsCertificate :: TlsCertificateK o => o -> IO TlsCertificate+toTlsCertificate = unsafeCastTo TlsCertificate++noTlsCertificate :: Maybe TlsCertificate+noTlsCertificate = Nothing++-- VVV Prop "certificate"+   -- Type: TByteArray+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getTlsCertificateCertificate :: (MonadIO m, TlsCertificateK o) => o -> m ByteString+getTlsCertificateCertificate obj = liftIO $ getObjectPropertyByteArray obj "certificate"++constructTlsCertificateCertificate :: ByteString -> IO ([Char], GValue)+constructTlsCertificateCertificate val = constructObjectPropertyByteArray "certificate" val++data TlsCertificateCertificatePropertyInfo+instance AttrInfo TlsCertificateCertificatePropertyInfo where+    type AttrAllowedOps TlsCertificateCertificatePropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TlsCertificateCertificatePropertyInfo = (~) ByteString+    type AttrBaseTypeConstraint TlsCertificateCertificatePropertyInfo = TlsCertificateK+    type AttrGetType TlsCertificateCertificatePropertyInfo = ByteString+    type AttrLabel TlsCertificateCertificatePropertyInfo = "TlsCertificate::certificate"+    attrGet _ = getTlsCertificateCertificate+    attrSet _ = undefined+    attrConstruct _ = constructTlsCertificateCertificate++-- VVV Prop "certificate-pem"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getTlsCertificateCertificatePem :: (MonadIO m, TlsCertificateK o) => o -> m T.Text+getTlsCertificateCertificatePem obj = liftIO $ getObjectPropertyString obj "certificate-pem"++constructTlsCertificateCertificatePem :: T.Text -> IO ([Char], GValue)+constructTlsCertificateCertificatePem val = constructObjectPropertyString "certificate-pem" val++data TlsCertificateCertificatePemPropertyInfo+instance AttrInfo TlsCertificateCertificatePemPropertyInfo where+    type AttrAllowedOps TlsCertificateCertificatePemPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TlsCertificateCertificatePemPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint TlsCertificateCertificatePemPropertyInfo = TlsCertificateK+    type AttrGetType TlsCertificateCertificatePemPropertyInfo = T.Text+    type AttrLabel TlsCertificateCertificatePemPropertyInfo = "TlsCertificate::certificate-pem"+    attrGet _ = getTlsCertificateCertificatePem+    attrSet _ = undefined+    attrConstruct _ = constructTlsCertificateCertificatePem++-- VVV Prop "issuer"+   -- Type: TInterface "Gio" "TlsCertificate"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getTlsCertificateIssuer :: (MonadIO m, TlsCertificateK o) => o -> m TlsCertificate+getTlsCertificateIssuer obj = liftIO $ getObjectPropertyObject obj "issuer" TlsCertificate++constructTlsCertificateIssuer :: (TlsCertificateK a) => a -> IO ([Char], GValue)+constructTlsCertificateIssuer val = constructObjectPropertyObject "issuer" val++data TlsCertificateIssuerPropertyInfo+instance AttrInfo TlsCertificateIssuerPropertyInfo where+    type AttrAllowedOps TlsCertificateIssuerPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TlsCertificateIssuerPropertyInfo = TlsCertificateK+    type AttrBaseTypeConstraint TlsCertificateIssuerPropertyInfo = TlsCertificateK+    type AttrGetType TlsCertificateIssuerPropertyInfo = TlsCertificate+    type AttrLabel TlsCertificateIssuerPropertyInfo = "TlsCertificate::issuer"+    attrGet _ = getTlsCertificateIssuer+    attrSet _ = undefined+    attrConstruct _ = constructTlsCertificateIssuer++-- VVV Prop "private-key"+   -- Type: TByteArray+   -- Flags: [PropertyWritable,PropertyConstructOnly]++constructTlsCertificatePrivateKey :: ByteString -> IO ([Char], GValue)+constructTlsCertificatePrivateKey val = constructObjectPropertyByteArray "private-key" val++data TlsCertificatePrivateKeyPropertyInfo+instance AttrInfo TlsCertificatePrivateKeyPropertyInfo where+    type AttrAllowedOps TlsCertificatePrivateKeyPropertyInfo = '[ 'AttrConstruct]+    type AttrSetTypeConstraint TlsCertificatePrivateKeyPropertyInfo = (~) ByteString+    type AttrBaseTypeConstraint TlsCertificatePrivateKeyPropertyInfo = TlsCertificateK+    type AttrGetType TlsCertificatePrivateKeyPropertyInfo = ()+    type AttrLabel TlsCertificatePrivateKeyPropertyInfo = "TlsCertificate::private-key"+    attrGet _ = undefined+    attrSet _ = undefined+    attrConstruct _ = constructTlsCertificatePrivateKey++-- VVV Prop "private-key-pem"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyWritable,PropertyConstructOnly]++constructTlsCertificatePrivateKeyPem :: T.Text -> IO ([Char], GValue)+constructTlsCertificatePrivateKeyPem val = constructObjectPropertyString "private-key-pem" val++data TlsCertificatePrivateKeyPemPropertyInfo+instance AttrInfo TlsCertificatePrivateKeyPemPropertyInfo where+    type AttrAllowedOps TlsCertificatePrivateKeyPemPropertyInfo = '[ 'AttrConstruct]+    type AttrSetTypeConstraint TlsCertificatePrivateKeyPemPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint TlsCertificatePrivateKeyPemPropertyInfo = TlsCertificateK+    type AttrGetType TlsCertificatePrivateKeyPemPropertyInfo = ()+    type AttrLabel TlsCertificatePrivateKeyPemPropertyInfo = "TlsCertificate::private-key-pem"+    attrGet _ = undefined+    attrSet _ = undefined+    attrConstruct _ = constructTlsCertificatePrivateKeyPem++type instance AttributeList TlsCertificate = TlsCertificateAttributeList+type TlsCertificateAttributeList = ('[ '("certificate", TlsCertificateCertificatePropertyInfo), '("certificate-pem", TlsCertificateCertificatePemPropertyInfo), '("issuer", TlsCertificateIssuerPropertyInfo), '("private-key", TlsCertificatePrivateKeyPropertyInfo), '("private-key-pem", TlsCertificatePrivateKeyPemPropertyInfo)] :: [(Symbol, *)])++type instance SignalList TlsCertificate = TlsCertificateSignalList+type TlsCertificateSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method TlsCertificate::new_from_file+-- method type : Constructor+-- Args : [Arg {argName = "file", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "file", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TlsCertificate"+-- throws : True+-- Skip return : False++foreign import ccall "g_tls_certificate_new_from_file" g_tls_certificate_new_from_file :: +    CString ->                              -- file : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr TlsCertificate)+++tlsCertificateNewFromFile ::+    (MonadIO m) =>+    T.Text ->                               -- file+    m TlsCertificate+tlsCertificateNewFromFile file = liftIO $ do+    file' <- textToCString file+    onException (do+        result <- propagateGError $ g_tls_certificate_new_from_file file'+        checkUnexpectedReturnNULL "g_tls_certificate_new_from_file" result+        result' <- (wrapObject TlsCertificate) result+        freeMem file'+        return result'+     ) (do+        freeMem file'+     )++-- method TlsCertificate::new_from_files+-- method type : Constructor+-- Args : [Arg {argName = "cert_file", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key_file", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "cert_file", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key_file", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TlsCertificate"+-- throws : True+-- Skip return : False++foreign import ccall "g_tls_certificate_new_from_files" g_tls_certificate_new_from_files :: +    CString ->                              -- cert_file : TBasicType TUTF8+    CString ->                              -- key_file : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr TlsCertificate)+++tlsCertificateNewFromFiles ::+    (MonadIO m) =>+    T.Text ->                               -- cert_file+    T.Text ->                               -- key_file+    m TlsCertificate+tlsCertificateNewFromFiles cert_file key_file = liftIO $ do+    cert_file' <- textToCString cert_file+    key_file' <- textToCString key_file+    onException (do+        result <- propagateGError $ g_tls_certificate_new_from_files cert_file' key_file'+        checkUnexpectedReturnNULL "g_tls_certificate_new_from_files" result+        result' <- (wrapObject TlsCertificate) result+        freeMem cert_file'+        freeMem key_file'+        return result'+     ) (do+        freeMem cert_file'+        freeMem key_file'+     )++-- method TlsCertificate::new_from_pem+-- method type : Constructor+-- Args : [Arg {argName = "data", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "data", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TlsCertificate"+-- throws : True+-- Skip return : False++foreign import ccall "g_tls_certificate_new_from_pem" g_tls_certificate_new_from_pem :: +    CString ->                              -- data : TBasicType TUTF8+    Int64 ->                                -- length : TBasicType TInt64+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr TlsCertificate)+++tlsCertificateNewFromPem ::+    (MonadIO m) =>+    T.Text ->                               -- data+    Int64 ->                                -- length+    m TlsCertificate+tlsCertificateNewFromPem data_ length_ = liftIO $ do+    data_' <- textToCString data_+    onException (do+        result <- propagateGError $ g_tls_certificate_new_from_pem data_' length_+        checkUnexpectedReturnNULL "g_tls_certificate_new_from_pem" result+        result' <- (wrapObject TlsCertificate) result+        freeMem data_'+        return result'+     ) (do+        freeMem data_'+     )++-- method TlsCertificate::get_issuer+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsCertificate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsCertificate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TlsCertificate"+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_certificate_get_issuer" g_tls_certificate_get_issuer :: +    Ptr TlsCertificate ->                   -- _obj : TInterface "Gio" "TlsCertificate"+    IO (Ptr TlsCertificate)+++tlsCertificateGetIssuer ::+    (MonadIO m, TlsCertificateK a) =>+    a ->                                    -- _obj+    m TlsCertificate+tlsCertificateGetIssuer _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_tls_certificate_get_issuer _obj'+    checkUnexpectedReturnNULL "g_tls_certificate_get_issuer" result+    result' <- (newObject TlsCertificate) result+    touchManagedPtr _obj+    return result'++-- method TlsCertificate::is_same+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsCertificate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cert_two", argType = TInterface "Gio" "TlsCertificate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsCertificate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cert_two", argType = TInterface "Gio" "TlsCertificate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_certificate_is_same" g_tls_certificate_is_same :: +    Ptr TlsCertificate ->                   -- _obj : TInterface "Gio" "TlsCertificate"+    Ptr TlsCertificate ->                   -- cert_two : TInterface "Gio" "TlsCertificate"+    IO CInt+++tlsCertificateIsSame ::+    (MonadIO m, TlsCertificateK a, TlsCertificateK b) =>+    a ->                                    -- _obj+    b ->                                    -- cert_two+    m Bool+tlsCertificateIsSame _obj cert_two = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let cert_two' = unsafeManagedPtrCastPtr cert_two+    result <- g_tls_certificate_is_same _obj' cert_two'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr cert_two+    return result'++-- method TlsCertificate::verify+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsCertificate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "identity", argType = TInterface "Gio" "SocketConnectable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "trusted_ca", argType = TInterface "Gio" "TlsCertificate", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsCertificate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "identity", argType = TInterface "Gio" "SocketConnectable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "trusted_ca", argType = TInterface "Gio" "TlsCertificate", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TlsCertificateFlags"+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_certificate_verify" g_tls_certificate_verify :: +    Ptr TlsCertificate ->                   -- _obj : TInterface "Gio" "TlsCertificate"+    Ptr SocketConnectable ->                -- identity : TInterface "Gio" "SocketConnectable"+    Ptr TlsCertificate ->                   -- trusted_ca : TInterface "Gio" "TlsCertificate"+    IO CUInt+++tlsCertificateVerify ::+    (MonadIO m, TlsCertificateK a, SocketConnectableK b, TlsCertificateK c) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- identity+    Maybe (c) ->                            -- trusted_ca+    m [TlsCertificateFlags]+tlsCertificateVerify _obj identity trusted_ca = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeIdentity <- case identity of+        Nothing -> return nullPtr+        Just jIdentity -> do+            let jIdentity' = unsafeManagedPtrCastPtr jIdentity+            return jIdentity'+    maybeTrusted_ca <- case trusted_ca of+        Nothing -> return nullPtr+        Just jTrusted_ca -> do+            let jTrusted_ca' = unsafeManagedPtrCastPtr jTrusted_ca+            return jTrusted_ca'+    result <- g_tls_certificate_verify _obj' maybeIdentity maybeTrusted_ca+    let result' = wordToGFlags result+    touchManagedPtr _obj+    whenJust identity touchManagedPtr+    whenJust trusted_ca touchManagedPtr+    return result'++-- method TlsCertificate::list_new_from_file+-- method type : MemberFunction+-- Args : [Arg {argName = "file", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "file", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gio" "TlsCertificate")+-- throws : True+-- Skip return : False++foreign import ccall "g_tls_certificate_list_new_from_file" g_tls_certificate_list_new_from_file :: +    CString ->                              -- file : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr (GList (Ptr TlsCertificate)))+++tlsCertificateListNewFromFile ::+    (MonadIO m) =>+    T.Text ->                               -- file+    m [TlsCertificate]+tlsCertificateListNewFromFile file = liftIO $ do+    file' <- textToCString file+    onException (do+        result <- propagateGError $ g_tls_certificate_list_new_from_file file'+        checkUnexpectedReturnNULL "g_tls_certificate_list_new_from_file" result+        result' <- unpackGList result+        result'' <- mapM (wrapObject TlsCertificate) result'+        g_list_free result+        freeMem file'+        return result''+     ) (do+        freeMem file'+     )++
+ GI/Gio/Objects/TlsCertificate.hs-boot view
@@ -0,0 +1,18 @@+module GI.Gio.Objects.TlsCertificate where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype TlsCertificate = TlsCertificate (ForeignPtr TlsCertificate)+instance GObject TlsCertificate where+class GObject o => TlsCertificateK o+instance (GObject o, IsDescendantOf TlsCertificate o) => TlsCertificateK o+data TlsCertificateCertificatePropertyInfo+data TlsCertificateCertificatePemPropertyInfo+data TlsCertificateIssuerPropertyInfo+data TlsCertificatePrivateKeyPropertyInfo+data TlsCertificatePrivateKeyPemPropertyInfo
+ GI/Gio/Objects/TlsConnection.hs view
@@ -0,0 +1,983 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.TlsConnection+    ( ++-- * Exported types+    TlsConnection(..)                       ,+    TlsConnectionK                          ,+    toTlsConnection                         ,+    noTlsConnection                         ,+++ -- * Methods+-- ** tlsConnectionEmitAcceptCertificate+    tlsConnectionEmitAcceptCertificate      ,+++-- ** tlsConnectionGetCertificate+    tlsConnectionGetCertificate             ,+++-- ** tlsConnectionGetDatabase+    tlsConnectionGetDatabase                ,+++-- ** tlsConnectionGetInteraction+    tlsConnectionGetInteraction             ,+++-- ** tlsConnectionGetPeerCertificate+    tlsConnectionGetPeerCertificate         ,+++-- ** tlsConnectionGetPeerCertificateErrors+    tlsConnectionGetPeerCertificateErrors   ,+++-- ** tlsConnectionGetRehandshakeMode+    tlsConnectionGetRehandshakeMode         ,+++-- ** tlsConnectionGetRequireCloseNotify+    tlsConnectionGetRequireCloseNotify      ,+++-- ** tlsConnectionGetUseSystemCertdb+    tlsConnectionGetUseSystemCertdb         ,+++-- ** tlsConnectionHandshake+    tlsConnectionHandshake                  ,+++-- ** tlsConnectionHandshakeAsync+    tlsConnectionHandshakeAsync             ,+++-- ** tlsConnectionHandshakeFinish+    tlsConnectionHandshakeFinish            ,+++-- ** tlsConnectionSetCertificate+    tlsConnectionSetCertificate             ,+++-- ** tlsConnectionSetDatabase+    tlsConnectionSetDatabase                ,+++-- ** tlsConnectionSetInteraction+    tlsConnectionSetInteraction             ,+++-- ** tlsConnectionSetRehandshakeMode+    tlsConnectionSetRehandshakeMode         ,+++-- ** tlsConnectionSetRequireCloseNotify+    tlsConnectionSetRequireCloseNotify      ,+++-- ** tlsConnectionSetUseSystemCertdb+    tlsConnectionSetUseSystemCertdb         ,+++++ -- * Properties+-- ** BaseIoStream+    TlsConnectionBaseIoStreamPropertyInfo   ,+    constructTlsConnectionBaseIoStream      ,+    getTlsConnectionBaseIoStream            ,+++-- ** Certificate+    TlsConnectionCertificatePropertyInfo    ,+    constructTlsConnectionCertificate       ,+    getTlsConnectionCertificate             ,+    setTlsConnectionCertificate             ,+++-- ** Database+    TlsConnectionDatabasePropertyInfo       ,+    constructTlsConnectionDatabase          ,+    getTlsConnectionDatabase                ,+    setTlsConnectionDatabase                ,+++-- ** Interaction+    TlsConnectionInteractionPropertyInfo    ,+    constructTlsConnectionInteraction       ,+    getTlsConnectionInteraction             ,+    setTlsConnectionInteraction             ,+++-- ** PeerCertificate+    TlsConnectionPeerCertificatePropertyInfo,+    getTlsConnectionPeerCertificate         ,+++-- ** PeerCertificateErrors+    TlsConnectionPeerCertificateErrorsPropertyInfo,+    getTlsConnectionPeerCertificateErrors   ,+++-- ** RehandshakeMode+    TlsConnectionRehandshakeModePropertyInfo,+    constructTlsConnectionRehandshakeMode   ,+    getTlsConnectionRehandshakeMode         ,+    setTlsConnectionRehandshakeMode         ,+++-- ** RequireCloseNotify+    TlsConnectionRequireCloseNotifyPropertyInfo,+    constructTlsConnectionRequireCloseNotify,+    getTlsConnectionRequireCloseNotify      ,+    setTlsConnectionRequireCloseNotify      ,+++-- ** UseSystemCertdb+    TlsConnectionUseSystemCertdbPropertyInfo,+    constructTlsConnectionUseSystemCertdb   ,+    getTlsConnectionUseSystemCertdb         ,+    setTlsConnectionUseSystemCertdb         ,+++++ -- * Signals+-- ** AcceptCertificate+    TlsConnectionAcceptCertificateCallback  ,+    TlsConnectionAcceptCertificateCallbackC ,+    TlsConnectionAcceptCertificateSignalInfo,+    afterTlsConnectionAcceptCertificate     ,+    mkTlsConnectionAcceptCertificateCallback,+    noTlsConnectionAcceptCertificateCallback,+    onTlsConnectionAcceptCertificate        ,+    tlsConnectionAcceptCertificateCallbackWrapper,+    tlsConnectionAcceptCertificateClosure   ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype TlsConnection = TlsConnection (ForeignPtr TlsConnection)+foreign import ccall "g_tls_connection_get_type"+    c_g_tls_connection_get_type :: IO GType++type instance ParentTypes TlsConnection = TlsConnectionParentTypes+type TlsConnectionParentTypes = '[IOStream, GObject.Object]++instance GObject TlsConnection where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_tls_connection_get_type+    ++class GObject o => TlsConnectionK o+instance (GObject o, IsDescendantOf TlsConnection o) => TlsConnectionK o++toTlsConnection :: TlsConnectionK o => o -> IO TlsConnection+toTlsConnection = unsafeCastTo TlsConnection++noTlsConnection :: Maybe TlsConnection+noTlsConnection = Nothing++-- signal TlsConnection::accept-certificate+type TlsConnectionAcceptCertificateCallback =+    TlsCertificate ->+    [TlsCertificateFlags] ->+    IO Bool++noTlsConnectionAcceptCertificateCallback :: Maybe TlsConnectionAcceptCertificateCallback+noTlsConnectionAcceptCertificateCallback = Nothing++type TlsConnectionAcceptCertificateCallbackC =+    Ptr () ->                               -- object+    Ptr TlsCertificate ->+    CUInt ->+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkTlsConnectionAcceptCertificateCallback :: TlsConnectionAcceptCertificateCallbackC -> IO (FunPtr TlsConnectionAcceptCertificateCallbackC)++tlsConnectionAcceptCertificateClosure :: TlsConnectionAcceptCertificateCallback -> IO Closure+tlsConnectionAcceptCertificateClosure cb = newCClosure =<< mkTlsConnectionAcceptCertificateCallback wrapped+    where wrapped = tlsConnectionAcceptCertificateCallbackWrapper cb++tlsConnectionAcceptCertificateCallbackWrapper ::+    TlsConnectionAcceptCertificateCallback ->+    Ptr () ->+    Ptr TlsCertificate ->+    CUInt ->+    Ptr () ->+    IO CInt+tlsConnectionAcceptCertificateCallbackWrapper _cb _ peer_cert errors _ = do+    peer_cert' <- (newObject TlsCertificate) peer_cert+    let errors' = wordToGFlags errors+    result <- _cb  peer_cert' errors'+    let result' = (fromIntegral . fromEnum) result+    return result'++onTlsConnectionAcceptCertificate :: (GObject a, MonadIO m) => a -> TlsConnectionAcceptCertificateCallback -> m SignalHandlerId+onTlsConnectionAcceptCertificate obj cb = liftIO $ connectTlsConnectionAcceptCertificate obj cb SignalConnectBefore+afterTlsConnectionAcceptCertificate :: (GObject a, MonadIO m) => a -> TlsConnectionAcceptCertificateCallback -> m SignalHandlerId+afterTlsConnectionAcceptCertificate obj cb = connectTlsConnectionAcceptCertificate obj cb SignalConnectAfter++connectTlsConnectionAcceptCertificate :: (GObject a, MonadIO m) =>+                                         a -> TlsConnectionAcceptCertificateCallback -> SignalConnectMode -> m SignalHandlerId+connectTlsConnectionAcceptCertificate obj cb after = liftIO $ do+    cb' <- mkTlsConnectionAcceptCertificateCallback (tlsConnectionAcceptCertificateCallbackWrapper cb)+    connectSignalFunPtr obj "accept-certificate" cb' after++-- VVV Prop "base-io-stream"+   -- Type: TInterface "Gio" "IOStream"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getTlsConnectionBaseIoStream :: (MonadIO m, TlsConnectionK o) => o -> m IOStream+getTlsConnectionBaseIoStream obj = liftIO $ getObjectPropertyObject obj "base-io-stream" IOStream++constructTlsConnectionBaseIoStream :: (IOStreamK a) => a -> IO ([Char], GValue)+constructTlsConnectionBaseIoStream val = constructObjectPropertyObject "base-io-stream" val++data TlsConnectionBaseIoStreamPropertyInfo+instance AttrInfo TlsConnectionBaseIoStreamPropertyInfo where+    type AttrAllowedOps TlsConnectionBaseIoStreamPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TlsConnectionBaseIoStreamPropertyInfo = IOStreamK+    type AttrBaseTypeConstraint TlsConnectionBaseIoStreamPropertyInfo = TlsConnectionK+    type AttrGetType TlsConnectionBaseIoStreamPropertyInfo = IOStream+    type AttrLabel TlsConnectionBaseIoStreamPropertyInfo = "TlsConnection::base-io-stream"+    attrGet _ = getTlsConnectionBaseIoStream+    attrSet _ = undefined+    attrConstruct _ = constructTlsConnectionBaseIoStream++-- VVV Prop "certificate"+   -- Type: TInterface "Gio" "TlsCertificate"+   -- Flags: [PropertyReadable,PropertyWritable]++getTlsConnectionCertificate :: (MonadIO m, TlsConnectionK o) => o -> m TlsCertificate+getTlsConnectionCertificate obj = liftIO $ getObjectPropertyObject obj "certificate" TlsCertificate++setTlsConnectionCertificate :: (MonadIO m, TlsConnectionK o, TlsCertificateK a) => o -> a -> m ()+setTlsConnectionCertificate obj val = liftIO $ setObjectPropertyObject obj "certificate" val++constructTlsConnectionCertificate :: (TlsCertificateK a) => a -> IO ([Char], GValue)+constructTlsConnectionCertificate val = constructObjectPropertyObject "certificate" val++data TlsConnectionCertificatePropertyInfo+instance AttrInfo TlsConnectionCertificatePropertyInfo where+    type AttrAllowedOps TlsConnectionCertificatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TlsConnectionCertificatePropertyInfo = TlsCertificateK+    type AttrBaseTypeConstraint TlsConnectionCertificatePropertyInfo = TlsConnectionK+    type AttrGetType TlsConnectionCertificatePropertyInfo = TlsCertificate+    type AttrLabel TlsConnectionCertificatePropertyInfo = "TlsConnection::certificate"+    attrGet _ = getTlsConnectionCertificate+    attrSet _ = setTlsConnectionCertificate+    attrConstruct _ = constructTlsConnectionCertificate++-- VVV Prop "database"+   -- Type: TInterface "Gio" "TlsDatabase"+   -- Flags: [PropertyReadable,PropertyWritable]++getTlsConnectionDatabase :: (MonadIO m, TlsConnectionK o) => o -> m TlsDatabase+getTlsConnectionDatabase obj = liftIO $ getObjectPropertyObject obj "database" TlsDatabase++setTlsConnectionDatabase :: (MonadIO m, TlsConnectionK o, TlsDatabaseK a) => o -> a -> m ()+setTlsConnectionDatabase obj val = liftIO $ setObjectPropertyObject obj "database" val++constructTlsConnectionDatabase :: (TlsDatabaseK a) => a -> IO ([Char], GValue)+constructTlsConnectionDatabase val = constructObjectPropertyObject "database" val++data TlsConnectionDatabasePropertyInfo+instance AttrInfo TlsConnectionDatabasePropertyInfo where+    type AttrAllowedOps TlsConnectionDatabasePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TlsConnectionDatabasePropertyInfo = TlsDatabaseK+    type AttrBaseTypeConstraint TlsConnectionDatabasePropertyInfo = TlsConnectionK+    type AttrGetType TlsConnectionDatabasePropertyInfo = TlsDatabase+    type AttrLabel TlsConnectionDatabasePropertyInfo = "TlsConnection::database"+    attrGet _ = getTlsConnectionDatabase+    attrSet _ = setTlsConnectionDatabase+    attrConstruct _ = constructTlsConnectionDatabase++-- VVV Prop "interaction"+   -- Type: TInterface "Gio" "TlsInteraction"+   -- Flags: [PropertyReadable,PropertyWritable]++getTlsConnectionInteraction :: (MonadIO m, TlsConnectionK o) => o -> m TlsInteraction+getTlsConnectionInteraction obj = liftIO $ getObjectPropertyObject obj "interaction" TlsInteraction++setTlsConnectionInteraction :: (MonadIO m, TlsConnectionK o, TlsInteractionK a) => o -> a -> m ()+setTlsConnectionInteraction obj val = liftIO $ setObjectPropertyObject obj "interaction" val++constructTlsConnectionInteraction :: (TlsInteractionK a) => a -> IO ([Char], GValue)+constructTlsConnectionInteraction val = constructObjectPropertyObject "interaction" val++data TlsConnectionInteractionPropertyInfo+instance AttrInfo TlsConnectionInteractionPropertyInfo where+    type AttrAllowedOps TlsConnectionInteractionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TlsConnectionInteractionPropertyInfo = TlsInteractionK+    type AttrBaseTypeConstraint TlsConnectionInteractionPropertyInfo = TlsConnectionK+    type AttrGetType TlsConnectionInteractionPropertyInfo = TlsInteraction+    type AttrLabel TlsConnectionInteractionPropertyInfo = "TlsConnection::interaction"+    attrGet _ = getTlsConnectionInteraction+    attrSet _ = setTlsConnectionInteraction+    attrConstruct _ = constructTlsConnectionInteraction++-- VVV Prop "peer-certificate"+   -- Type: TInterface "Gio" "TlsCertificate"+   -- Flags: [PropertyReadable]++getTlsConnectionPeerCertificate :: (MonadIO m, TlsConnectionK o) => o -> m TlsCertificate+getTlsConnectionPeerCertificate obj = liftIO $ getObjectPropertyObject obj "peer-certificate" TlsCertificate++data TlsConnectionPeerCertificatePropertyInfo+instance AttrInfo TlsConnectionPeerCertificatePropertyInfo where+    type AttrAllowedOps TlsConnectionPeerCertificatePropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint TlsConnectionPeerCertificatePropertyInfo = (~) ()+    type AttrBaseTypeConstraint TlsConnectionPeerCertificatePropertyInfo = TlsConnectionK+    type AttrGetType TlsConnectionPeerCertificatePropertyInfo = TlsCertificate+    type AttrLabel TlsConnectionPeerCertificatePropertyInfo = "TlsConnection::peer-certificate"+    attrGet _ = getTlsConnectionPeerCertificate+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "peer-certificate-errors"+   -- Type: TInterface "Gio" "TlsCertificateFlags"+   -- Flags: [PropertyReadable]++getTlsConnectionPeerCertificateErrors :: (MonadIO m, TlsConnectionK o) => o -> m [TlsCertificateFlags]+getTlsConnectionPeerCertificateErrors obj = liftIO $ getObjectPropertyFlags obj "peer-certificate-errors"++data TlsConnectionPeerCertificateErrorsPropertyInfo+instance AttrInfo TlsConnectionPeerCertificateErrorsPropertyInfo where+    type AttrAllowedOps TlsConnectionPeerCertificateErrorsPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint TlsConnectionPeerCertificateErrorsPropertyInfo = (~) ()+    type AttrBaseTypeConstraint TlsConnectionPeerCertificateErrorsPropertyInfo = TlsConnectionK+    type AttrGetType TlsConnectionPeerCertificateErrorsPropertyInfo = [TlsCertificateFlags]+    type AttrLabel TlsConnectionPeerCertificateErrorsPropertyInfo = "TlsConnection::peer-certificate-errors"+    attrGet _ = getTlsConnectionPeerCertificateErrors+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "rehandshake-mode"+   -- Type: TInterface "Gio" "TlsRehandshakeMode"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getTlsConnectionRehandshakeMode :: (MonadIO m, TlsConnectionK o) => o -> m TlsRehandshakeMode+getTlsConnectionRehandshakeMode obj = liftIO $ getObjectPropertyEnum obj "rehandshake-mode"++setTlsConnectionRehandshakeMode :: (MonadIO m, TlsConnectionK o) => o -> TlsRehandshakeMode -> m ()+setTlsConnectionRehandshakeMode obj val = liftIO $ setObjectPropertyEnum obj "rehandshake-mode" val++constructTlsConnectionRehandshakeMode :: TlsRehandshakeMode -> IO ([Char], GValue)+constructTlsConnectionRehandshakeMode val = constructObjectPropertyEnum "rehandshake-mode" val++data TlsConnectionRehandshakeModePropertyInfo+instance AttrInfo TlsConnectionRehandshakeModePropertyInfo where+    type AttrAllowedOps TlsConnectionRehandshakeModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TlsConnectionRehandshakeModePropertyInfo = (~) TlsRehandshakeMode+    type AttrBaseTypeConstraint TlsConnectionRehandshakeModePropertyInfo = TlsConnectionK+    type AttrGetType TlsConnectionRehandshakeModePropertyInfo = TlsRehandshakeMode+    type AttrLabel TlsConnectionRehandshakeModePropertyInfo = "TlsConnection::rehandshake-mode"+    attrGet _ = getTlsConnectionRehandshakeMode+    attrSet _ = setTlsConnectionRehandshakeMode+    attrConstruct _ = constructTlsConnectionRehandshakeMode++-- VVV Prop "require-close-notify"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getTlsConnectionRequireCloseNotify :: (MonadIO m, TlsConnectionK o) => o -> m Bool+getTlsConnectionRequireCloseNotify obj = liftIO $ getObjectPropertyBool obj "require-close-notify"++setTlsConnectionRequireCloseNotify :: (MonadIO m, TlsConnectionK o) => o -> Bool -> m ()+setTlsConnectionRequireCloseNotify obj val = liftIO $ setObjectPropertyBool obj "require-close-notify" val++constructTlsConnectionRequireCloseNotify :: Bool -> IO ([Char], GValue)+constructTlsConnectionRequireCloseNotify val = constructObjectPropertyBool "require-close-notify" val++data TlsConnectionRequireCloseNotifyPropertyInfo+instance AttrInfo TlsConnectionRequireCloseNotifyPropertyInfo where+    type AttrAllowedOps TlsConnectionRequireCloseNotifyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TlsConnectionRequireCloseNotifyPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint TlsConnectionRequireCloseNotifyPropertyInfo = TlsConnectionK+    type AttrGetType TlsConnectionRequireCloseNotifyPropertyInfo = Bool+    type AttrLabel TlsConnectionRequireCloseNotifyPropertyInfo = "TlsConnection::require-close-notify"+    attrGet _ = getTlsConnectionRequireCloseNotify+    attrSet _ = setTlsConnectionRequireCloseNotify+    attrConstruct _ = constructTlsConnectionRequireCloseNotify++-- VVV Prop "use-system-certdb"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getTlsConnectionUseSystemCertdb :: (MonadIO m, TlsConnectionK o) => o -> m Bool+getTlsConnectionUseSystemCertdb obj = liftIO $ getObjectPropertyBool obj "use-system-certdb"++setTlsConnectionUseSystemCertdb :: (MonadIO m, TlsConnectionK o) => o -> Bool -> m ()+setTlsConnectionUseSystemCertdb obj val = liftIO $ setObjectPropertyBool obj "use-system-certdb" val++constructTlsConnectionUseSystemCertdb :: Bool -> IO ([Char], GValue)+constructTlsConnectionUseSystemCertdb val = constructObjectPropertyBool "use-system-certdb" val++data TlsConnectionUseSystemCertdbPropertyInfo+instance AttrInfo TlsConnectionUseSystemCertdbPropertyInfo where+    type AttrAllowedOps TlsConnectionUseSystemCertdbPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TlsConnectionUseSystemCertdbPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint TlsConnectionUseSystemCertdbPropertyInfo = TlsConnectionK+    type AttrGetType TlsConnectionUseSystemCertdbPropertyInfo = Bool+    type AttrLabel TlsConnectionUseSystemCertdbPropertyInfo = "TlsConnection::use-system-certdb"+    attrGet _ = getTlsConnectionUseSystemCertdb+    attrSet _ = setTlsConnectionUseSystemCertdb+    attrConstruct _ = constructTlsConnectionUseSystemCertdb++type instance AttributeList TlsConnection = TlsConnectionAttributeList+type TlsConnectionAttributeList = ('[ '("base-io-stream", TlsConnectionBaseIoStreamPropertyInfo), '("certificate", TlsConnectionCertificatePropertyInfo), '("closed", IOStreamClosedPropertyInfo), '("database", TlsConnectionDatabasePropertyInfo), '("input-stream", IOStreamInputStreamPropertyInfo), '("interaction", TlsConnectionInteractionPropertyInfo), '("output-stream", IOStreamOutputStreamPropertyInfo), '("peer-certificate", TlsConnectionPeerCertificatePropertyInfo), '("peer-certificate-errors", TlsConnectionPeerCertificateErrorsPropertyInfo), '("rehandshake-mode", TlsConnectionRehandshakeModePropertyInfo), '("require-close-notify", TlsConnectionRequireCloseNotifyPropertyInfo), '("use-system-certdb", TlsConnectionUseSystemCertdbPropertyInfo)] :: [(Symbol, *)])++data TlsConnectionAcceptCertificateSignalInfo+instance SignalInfo TlsConnectionAcceptCertificateSignalInfo where+    type HaskellCallbackType TlsConnectionAcceptCertificateSignalInfo = TlsConnectionAcceptCertificateCallback+    connectSignal _ = connectTlsConnectionAcceptCertificate++type instance SignalList TlsConnection = TlsConnectionSignalList+type TlsConnectionSignalList = ('[ '("accept-certificate", TlsConnectionAcceptCertificateSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method TlsConnection::emit_accept_certificate+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "peer_cert", argType = TInterface "Gio" "TlsCertificate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "errors", argType = TInterface "Gio" "TlsCertificateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "peer_cert", argType = TInterface "Gio" "TlsCertificate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "errors", argType = TInterface "Gio" "TlsCertificateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_connection_emit_accept_certificate" g_tls_connection_emit_accept_certificate :: +    Ptr TlsConnection ->                    -- _obj : TInterface "Gio" "TlsConnection"+    Ptr TlsCertificate ->                   -- peer_cert : TInterface "Gio" "TlsCertificate"+    CUInt ->                                -- errors : TInterface "Gio" "TlsCertificateFlags"+    IO CInt+++tlsConnectionEmitAcceptCertificate ::+    (MonadIO m, TlsConnectionK a, TlsCertificateK b) =>+    a ->                                    -- _obj+    b ->                                    -- peer_cert+    [TlsCertificateFlags] ->                -- errors+    m Bool+tlsConnectionEmitAcceptCertificate _obj peer_cert errors = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let peer_cert' = unsafeManagedPtrCastPtr peer_cert+    let errors' = gflagsToWord errors+    result <- g_tls_connection_emit_accept_certificate _obj' peer_cert' errors'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr peer_cert+    return result'++-- method TlsConnection::get_certificate+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TlsCertificate"+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_connection_get_certificate" g_tls_connection_get_certificate :: +    Ptr TlsConnection ->                    -- _obj : TInterface "Gio" "TlsConnection"+    IO (Ptr TlsCertificate)+++tlsConnectionGetCertificate ::+    (MonadIO m, TlsConnectionK a) =>+    a ->                                    -- _obj+    m TlsCertificate+tlsConnectionGetCertificate _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_tls_connection_get_certificate _obj'+    checkUnexpectedReturnNULL "g_tls_connection_get_certificate" result+    result' <- (newObject TlsCertificate) result+    touchManagedPtr _obj+    return result'++-- method TlsConnection::get_database+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TlsDatabase"+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_connection_get_database" g_tls_connection_get_database :: +    Ptr TlsConnection ->                    -- _obj : TInterface "Gio" "TlsConnection"+    IO (Ptr TlsDatabase)+++tlsConnectionGetDatabase ::+    (MonadIO m, TlsConnectionK a) =>+    a ->                                    -- _obj+    m TlsDatabase+tlsConnectionGetDatabase _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_tls_connection_get_database _obj'+    checkUnexpectedReturnNULL "g_tls_connection_get_database" result+    result' <- (newObject TlsDatabase) result+    touchManagedPtr _obj+    return result'++-- method TlsConnection::get_interaction+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TlsInteraction"+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_connection_get_interaction" g_tls_connection_get_interaction :: +    Ptr TlsConnection ->                    -- _obj : TInterface "Gio" "TlsConnection"+    IO (Ptr TlsInteraction)+++tlsConnectionGetInteraction ::+    (MonadIO m, TlsConnectionK a) =>+    a ->                                    -- _obj+    m TlsInteraction+tlsConnectionGetInteraction _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_tls_connection_get_interaction _obj'+    checkUnexpectedReturnNULL "g_tls_connection_get_interaction" result+    result' <- (newObject TlsInteraction) result+    touchManagedPtr _obj+    return result'++-- method TlsConnection::get_peer_certificate+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TlsCertificate"+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_connection_get_peer_certificate" g_tls_connection_get_peer_certificate :: +    Ptr TlsConnection ->                    -- _obj : TInterface "Gio" "TlsConnection"+    IO (Ptr TlsCertificate)+++tlsConnectionGetPeerCertificate ::+    (MonadIO m, TlsConnectionK a) =>+    a ->                                    -- _obj+    m TlsCertificate+tlsConnectionGetPeerCertificate _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_tls_connection_get_peer_certificate _obj'+    checkUnexpectedReturnNULL "g_tls_connection_get_peer_certificate" result+    result' <- (newObject TlsCertificate) result+    touchManagedPtr _obj+    return result'++-- method TlsConnection::get_peer_certificate_errors+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TlsCertificateFlags"+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_connection_get_peer_certificate_errors" g_tls_connection_get_peer_certificate_errors :: +    Ptr TlsConnection ->                    -- _obj : TInterface "Gio" "TlsConnection"+    IO CUInt+++tlsConnectionGetPeerCertificateErrors ::+    (MonadIO m, TlsConnectionK a) =>+    a ->                                    -- _obj+    m [TlsCertificateFlags]+tlsConnectionGetPeerCertificateErrors _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_tls_connection_get_peer_certificate_errors _obj'+    let result' = wordToGFlags result+    touchManagedPtr _obj+    return result'++-- method TlsConnection::get_rehandshake_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TlsRehandshakeMode"+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_connection_get_rehandshake_mode" g_tls_connection_get_rehandshake_mode :: +    Ptr TlsConnection ->                    -- _obj : TInterface "Gio" "TlsConnection"+    IO CUInt+++tlsConnectionGetRehandshakeMode ::+    (MonadIO m, TlsConnectionK a) =>+    a ->                                    -- _obj+    m TlsRehandshakeMode+tlsConnectionGetRehandshakeMode _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_tls_connection_get_rehandshake_mode _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method TlsConnection::get_require_close_notify+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_connection_get_require_close_notify" g_tls_connection_get_require_close_notify :: +    Ptr TlsConnection ->                    -- _obj : TInterface "Gio" "TlsConnection"+    IO CInt+++tlsConnectionGetRequireCloseNotify ::+    (MonadIO m, TlsConnectionK a) =>+    a ->                                    -- _obj+    m Bool+tlsConnectionGetRequireCloseNotify _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_tls_connection_get_require_close_notify _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method TlsConnection::get_use_system_certdb+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_connection_get_use_system_certdb" g_tls_connection_get_use_system_certdb :: +    Ptr TlsConnection ->                    -- _obj : TInterface "Gio" "TlsConnection"+    IO CInt++{-# DEPRECATED tlsConnectionGetUseSystemCertdb ["(Since version 2.30)","Use g_tls_connection_get_database() instead"]#-}+tlsConnectionGetUseSystemCertdb ::+    (MonadIO m, TlsConnectionK a) =>+    a ->                                    -- _obj+    m Bool+tlsConnectionGetUseSystemCertdb _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_tls_connection_get_use_system_certdb _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method TlsConnection::handshake+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_tls_connection_handshake" g_tls_connection_handshake :: +    Ptr TlsConnection ->                    -- _obj : TInterface "Gio" "TlsConnection"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++tlsConnectionHandshake ::+    (MonadIO m, TlsConnectionK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m ()+tlsConnectionHandshake _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_tls_connection_handshake _obj' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method TlsConnection::handshake_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "io_priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_connection_handshake_async" g_tls_connection_handshake_async :: +    Ptr TlsConnection ->                    -- _obj : TInterface "Gio" "TlsConnection"+    Int32 ->                                -- io_priority : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++tlsConnectionHandshakeAsync ::+    (MonadIO m, TlsConnectionK a, CancellableK b) =>+    a ->                                    -- _obj+    Int32 ->                                -- io_priority+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+tlsConnectionHandshakeAsync _obj io_priority cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_tls_connection_handshake_async _obj' io_priority maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method TlsConnection::handshake_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_tls_connection_handshake_finish" g_tls_connection_handshake_finish :: +    Ptr TlsConnection ->                    -- _obj : TInterface "Gio" "TlsConnection"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++tlsConnectionHandshakeFinish ::+    (MonadIO m, TlsConnectionK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+tlsConnectionHandshakeFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_tls_connection_handshake_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++-- method TlsConnection::set_certificate+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "certificate", argType = TInterface "Gio" "TlsCertificate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "certificate", argType = TInterface "Gio" "TlsCertificate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_connection_set_certificate" g_tls_connection_set_certificate :: +    Ptr TlsConnection ->                    -- _obj : TInterface "Gio" "TlsConnection"+    Ptr TlsCertificate ->                   -- certificate : TInterface "Gio" "TlsCertificate"+    IO ()+++tlsConnectionSetCertificate ::+    (MonadIO m, TlsConnectionK a, TlsCertificateK b) =>+    a ->                                    -- _obj+    b ->                                    -- certificate+    m ()+tlsConnectionSetCertificate _obj certificate = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let certificate' = unsafeManagedPtrCastPtr certificate+    g_tls_connection_set_certificate _obj' certificate'+    touchManagedPtr _obj+    touchManagedPtr certificate+    return ()++-- method TlsConnection::set_database+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "database", argType = TInterface "Gio" "TlsDatabase", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "database", argType = TInterface "Gio" "TlsDatabase", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_connection_set_database" g_tls_connection_set_database :: +    Ptr TlsConnection ->                    -- _obj : TInterface "Gio" "TlsConnection"+    Ptr TlsDatabase ->                      -- database : TInterface "Gio" "TlsDatabase"+    IO ()+++tlsConnectionSetDatabase ::+    (MonadIO m, TlsConnectionK a, TlsDatabaseK b) =>+    a ->                                    -- _obj+    b ->                                    -- database+    m ()+tlsConnectionSetDatabase _obj database = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let database' = unsafeManagedPtrCastPtr database+    g_tls_connection_set_database _obj' database'+    touchManagedPtr _obj+    touchManagedPtr database+    return ()++-- method TlsConnection::set_interaction+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interaction", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interaction", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_connection_set_interaction" g_tls_connection_set_interaction :: +    Ptr TlsConnection ->                    -- _obj : TInterface "Gio" "TlsConnection"+    Ptr TlsInteraction ->                   -- interaction : TInterface "Gio" "TlsInteraction"+    IO ()+++tlsConnectionSetInteraction ::+    (MonadIO m, TlsConnectionK a, TlsInteractionK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- interaction+    m ()+tlsConnectionSetInteraction _obj interaction = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeInteraction <- case interaction of+        Nothing -> return nullPtr+        Just jInteraction -> do+            let jInteraction' = unsafeManagedPtrCastPtr jInteraction+            return jInteraction'+    g_tls_connection_set_interaction _obj' maybeInteraction+    touchManagedPtr _obj+    whenJust interaction touchManagedPtr+    return ()++-- method TlsConnection::set_rehandshake_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mode", argType = TInterface "Gio" "TlsRehandshakeMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mode", argType = TInterface "Gio" "TlsRehandshakeMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_connection_set_rehandshake_mode" g_tls_connection_set_rehandshake_mode :: +    Ptr TlsConnection ->                    -- _obj : TInterface "Gio" "TlsConnection"+    CUInt ->                                -- mode : TInterface "Gio" "TlsRehandshakeMode"+    IO ()+++tlsConnectionSetRehandshakeMode ::+    (MonadIO m, TlsConnectionK a) =>+    a ->                                    -- _obj+    TlsRehandshakeMode ->                   -- mode+    m ()+tlsConnectionSetRehandshakeMode _obj mode = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let mode' = (fromIntegral . fromEnum) mode+    g_tls_connection_set_rehandshake_mode _obj' mode'+    touchManagedPtr _obj+    return ()++-- method TlsConnection::set_require_close_notify+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "require_close_notify", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "require_close_notify", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_connection_set_require_close_notify" g_tls_connection_set_require_close_notify :: +    Ptr TlsConnection ->                    -- _obj : TInterface "Gio" "TlsConnection"+    CInt ->                                 -- require_close_notify : TBasicType TBoolean+    IO ()+++tlsConnectionSetRequireCloseNotify ::+    (MonadIO m, TlsConnectionK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- require_close_notify+    m ()+tlsConnectionSetRequireCloseNotify _obj require_close_notify = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let require_close_notify' = (fromIntegral . fromEnum) require_close_notify+    g_tls_connection_set_require_close_notify _obj' require_close_notify'+    touchManagedPtr _obj+    return ()++-- method TlsConnection::set_use_system_certdb+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_system_certdb", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_system_certdb", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_connection_set_use_system_certdb" g_tls_connection_set_use_system_certdb :: +    Ptr TlsConnection ->                    -- _obj : TInterface "Gio" "TlsConnection"+    CInt ->                                 -- use_system_certdb : TBasicType TBoolean+    IO ()++{-# DEPRECATED tlsConnectionSetUseSystemCertdb ["(Since version 2.30)","Use g_tls_connection_set_database() instead"]#-}+tlsConnectionSetUseSystemCertdb ::+    (MonadIO m, TlsConnectionK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- use_system_certdb+    m ()+tlsConnectionSetUseSystemCertdb _obj use_system_certdb = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let use_system_certdb' = (fromIntegral . fromEnum) use_system_certdb+    g_tls_connection_set_use_system_certdb _obj' use_system_certdb'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Objects/TlsConnection.hs-boot view
@@ -0,0 +1,23 @@+module GI.Gio.Objects.TlsConnection where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype TlsConnection = TlsConnection (ForeignPtr TlsConnection)+instance GObject TlsConnection where+class GObject o => TlsConnectionK o+instance (GObject o, IsDescendantOf TlsConnection o) => TlsConnectionK o+data TlsConnectionBaseIoStreamPropertyInfo+data TlsConnectionCertificatePropertyInfo+data TlsConnectionDatabasePropertyInfo+data TlsConnectionInteractionPropertyInfo+data TlsConnectionPeerCertificatePropertyInfo+data TlsConnectionPeerCertificateErrorsPropertyInfo+data TlsConnectionRehandshakeModePropertyInfo+data TlsConnectionRequireCloseNotifyPropertyInfo+data TlsConnectionUseSystemCertdbPropertyInfo+data TlsConnectionAcceptCertificateSignalInfo
+ GI/Gio/Objects/TlsDatabase.hs view
@@ -0,0 +1,758 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.TlsDatabase+    ( ++-- * Exported types+    TlsDatabase(..)                         ,+    TlsDatabaseK                            ,+    toTlsDatabase                           ,+    noTlsDatabase                           ,+++ -- * Methods+-- ** tlsDatabaseCreateCertificateHandle+    tlsDatabaseCreateCertificateHandle      ,+++-- ** tlsDatabaseLookupCertificateForHandle+    tlsDatabaseLookupCertificateForHandle   ,+++-- ** tlsDatabaseLookupCertificateForHandleAsync+    tlsDatabaseLookupCertificateForHandleAsync,+++-- ** tlsDatabaseLookupCertificateForHandleFinish+    tlsDatabaseLookupCertificateForHandleFinish,+++-- ** tlsDatabaseLookupCertificateIssuer+    tlsDatabaseLookupCertificateIssuer      ,+++-- ** tlsDatabaseLookupCertificateIssuerAsync+    tlsDatabaseLookupCertificateIssuerAsync ,+++-- ** tlsDatabaseLookupCertificateIssuerFinish+    tlsDatabaseLookupCertificateIssuerFinish,+++-- ** tlsDatabaseLookupCertificatesIssuedBy+    tlsDatabaseLookupCertificatesIssuedBy   ,+++-- ** tlsDatabaseLookupCertificatesIssuedByAsync+    tlsDatabaseLookupCertificatesIssuedByAsync,+++-- ** tlsDatabaseLookupCertificatesIssuedByFinish+    tlsDatabaseLookupCertificatesIssuedByFinish,+++-- ** tlsDatabaseVerifyChain+    tlsDatabaseVerifyChain                  ,+++-- ** tlsDatabaseVerifyChainAsync+    tlsDatabaseVerifyChainAsync             ,+++-- ** tlsDatabaseVerifyChainFinish+    tlsDatabaseVerifyChainFinish            ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype TlsDatabase = TlsDatabase (ForeignPtr TlsDatabase)+foreign import ccall "g_tls_database_get_type"+    c_g_tls_database_get_type :: IO GType++type instance ParentTypes TlsDatabase = TlsDatabaseParentTypes+type TlsDatabaseParentTypes = '[GObject.Object]++instance GObject TlsDatabase where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_tls_database_get_type+    ++class GObject o => TlsDatabaseK o+instance (GObject o, IsDescendantOf TlsDatabase o) => TlsDatabaseK o++toTlsDatabase :: TlsDatabaseK o => o -> IO TlsDatabase+toTlsDatabase = unsafeCastTo TlsDatabase++noTlsDatabase :: Maybe TlsDatabase+noTlsDatabase = Nothing++type instance AttributeList TlsDatabase = TlsDatabaseAttributeList+type TlsDatabaseAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList TlsDatabase = TlsDatabaseSignalList+type TlsDatabaseSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method TlsDatabase::create_certificate_handle+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsDatabase", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "certificate", argType = TInterface "Gio" "TlsCertificate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsDatabase", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "certificate", argType = TInterface "Gio" "TlsCertificate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_database_create_certificate_handle" g_tls_database_create_certificate_handle :: +    Ptr TlsDatabase ->                      -- _obj : TInterface "Gio" "TlsDatabase"+    Ptr TlsCertificate ->                   -- certificate : TInterface "Gio" "TlsCertificate"+    IO CString+++tlsDatabaseCreateCertificateHandle ::+    (MonadIO m, TlsDatabaseK a, TlsCertificateK b) =>+    a ->                                    -- _obj+    b ->                                    -- certificate+    m T.Text+tlsDatabaseCreateCertificateHandle _obj certificate = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let certificate' = unsafeManagedPtrCastPtr certificate+    result <- g_tls_database_create_certificate_handle _obj' certificate'+    checkUnexpectedReturnNULL "g_tls_database_create_certificate_handle" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    touchManagedPtr certificate+    return result'++-- method TlsDatabase::lookup_certificate_for_handle+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsDatabase", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "handle", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interaction", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "TlsDatabaseLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsDatabase", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "handle", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interaction", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "TlsDatabaseLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TlsCertificate"+-- throws : True+-- Skip return : False++foreign import ccall "g_tls_database_lookup_certificate_for_handle" g_tls_database_lookup_certificate_for_handle :: +    Ptr TlsDatabase ->                      -- _obj : TInterface "Gio" "TlsDatabase"+    CString ->                              -- handle : TBasicType TUTF8+    Ptr TlsInteraction ->                   -- interaction : TInterface "Gio" "TlsInteraction"+    CUInt ->                                -- flags : TInterface "Gio" "TlsDatabaseLookupFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr TlsCertificate)+++tlsDatabaseLookupCertificateForHandle ::+    (MonadIO m, TlsDatabaseK a, TlsInteractionK b, CancellableK c) =>+    a ->                                    -- _obj+    T.Text ->                               -- handle+    Maybe (b) ->                            -- interaction+    TlsDatabaseLookupFlags ->               -- flags+    Maybe (c) ->                            -- cancellable+    m TlsCertificate+tlsDatabaseLookupCertificateForHandle _obj handle interaction flags cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    handle' <- textToCString handle+    maybeInteraction <- case interaction of+        Nothing -> return nullPtr+        Just jInteraction -> do+            let jInteraction' = unsafeManagedPtrCastPtr jInteraction+            return jInteraction'+    let flags' = (fromIntegral . fromEnum) flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_tls_database_lookup_certificate_for_handle _obj' handle' maybeInteraction flags' maybeCancellable+        checkUnexpectedReturnNULL "g_tls_database_lookup_certificate_for_handle" result+        result' <- (wrapObject TlsCertificate) result+        touchManagedPtr _obj+        whenJust interaction touchManagedPtr+        whenJust cancellable touchManagedPtr+        freeMem handle'+        return result'+     ) (do+        freeMem handle'+     )++-- method TlsDatabase::lookup_certificate_for_handle_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsDatabase", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "handle", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interaction", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "TlsDatabaseLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsDatabase", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "handle", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interaction", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "TlsDatabaseLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_database_lookup_certificate_for_handle_async" g_tls_database_lookup_certificate_for_handle_async :: +    Ptr TlsDatabase ->                      -- _obj : TInterface "Gio" "TlsDatabase"+    CString ->                              -- handle : TBasicType TUTF8+    Ptr TlsInteraction ->                   -- interaction : TInterface "Gio" "TlsInteraction"+    CUInt ->                                -- flags : TInterface "Gio" "TlsDatabaseLookupFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++tlsDatabaseLookupCertificateForHandleAsync ::+    (MonadIO m, TlsDatabaseK a, TlsInteractionK b, CancellableK c) =>+    a ->                                    -- _obj+    T.Text ->                               -- handle+    Maybe (b) ->                            -- interaction+    TlsDatabaseLookupFlags ->               -- flags+    Maybe (c) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+tlsDatabaseLookupCertificateForHandleAsync _obj handle interaction flags cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    handle' <- textToCString handle+    maybeInteraction <- case interaction of+        Nothing -> return nullPtr+        Just jInteraction -> do+            let jInteraction' = unsafeManagedPtrCastPtr jInteraction+            return jInteraction'+    let flags' = (fromIntegral . fromEnum) flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_tls_database_lookup_certificate_for_handle_async _obj' handle' maybeInteraction flags' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust interaction touchManagedPtr+    whenJust cancellable touchManagedPtr+    freeMem handle'+    return ()++-- method TlsDatabase::lookup_certificate_for_handle_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsDatabase", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsDatabase", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TlsCertificate"+-- throws : True+-- Skip return : False++foreign import ccall "g_tls_database_lookup_certificate_for_handle_finish" g_tls_database_lookup_certificate_for_handle_finish :: +    Ptr TlsDatabase ->                      -- _obj : TInterface "Gio" "TlsDatabase"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr TlsCertificate)+++tlsDatabaseLookupCertificateForHandleFinish ::+    (MonadIO m, TlsDatabaseK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m TlsCertificate+tlsDatabaseLookupCertificateForHandleFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        result <- propagateGError $ g_tls_database_lookup_certificate_for_handle_finish _obj' result_'+        checkUnexpectedReturnNULL "g_tls_database_lookup_certificate_for_handle_finish" result+        result' <- (wrapObject TlsCertificate) result+        touchManagedPtr _obj+        touchManagedPtr result_+        return result'+     ) (do+        return ()+     )++-- method TlsDatabase::lookup_certificate_issuer+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsDatabase", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "certificate", argType = TInterface "Gio" "TlsCertificate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interaction", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "TlsDatabaseLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsDatabase", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "certificate", argType = TInterface "Gio" "TlsCertificate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interaction", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "TlsDatabaseLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TlsCertificate"+-- throws : True+-- Skip return : False++foreign import ccall "g_tls_database_lookup_certificate_issuer" g_tls_database_lookup_certificate_issuer :: +    Ptr TlsDatabase ->                      -- _obj : TInterface "Gio" "TlsDatabase"+    Ptr TlsCertificate ->                   -- certificate : TInterface "Gio" "TlsCertificate"+    Ptr TlsInteraction ->                   -- interaction : TInterface "Gio" "TlsInteraction"+    CUInt ->                                -- flags : TInterface "Gio" "TlsDatabaseLookupFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr TlsCertificate)+++tlsDatabaseLookupCertificateIssuer ::+    (MonadIO m, TlsDatabaseK a, TlsCertificateK b, TlsInteractionK c, CancellableK d) =>+    a ->                                    -- _obj+    b ->                                    -- certificate+    Maybe (c) ->                            -- interaction+    TlsDatabaseLookupFlags ->               -- flags+    Maybe (d) ->                            -- cancellable+    m TlsCertificate+tlsDatabaseLookupCertificateIssuer _obj certificate interaction flags cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let certificate' = unsafeManagedPtrCastPtr certificate+    maybeInteraction <- case interaction of+        Nothing -> return nullPtr+        Just jInteraction -> do+            let jInteraction' = unsafeManagedPtrCastPtr jInteraction+            return jInteraction'+    let flags' = (fromIntegral . fromEnum) flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_tls_database_lookup_certificate_issuer _obj' certificate' maybeInteraction flags' maybeCancellable+        checkUnexpectedReturnNULL "g_tls_database_lookup_certificate_issuer" result+        result' <- (wrapObject TlsCertificate) result+        touchManagedPtr _obj+        touchManagedPtr certificate+        whenJust interaction touchManagedPtr+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )++-- method TlsDatabase::lookup_certificate_issuer_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsDatabase", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "certificate", argType = TInterface "Gio" "TlsCertificate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interaction", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "TlsDatabaseLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsDatabase", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "certificate", argType = TInterface "Gio" "TlsCertificate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interaction", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "TlsDatabaseLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_database_lookup_certificate_issuer_async" g_tls_database_lookup_certificate_issuer_async :: +    Ptr TlsDatabase ->                      -- _obj : TInterface "Gio" "TlsDatabase"+    Ptr TlsCertificate ->                   -- certificate : TInterface "Gio" "TlsCertificate"+    Ptr TlsInteraction ->                   -- interaction : TInterface "Gio" "TlsInteraction"+    CUInt ->                                -- flags : TInterface "Gio" "TlsDatabaseLookupFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++tlsDatabaseLookupCertificateIssuerAsync ::+    (MonadIO m, TlsDatabaseK a, TlsCertificateK b, TlsInteractionK c, CancellableK d) =>+    a ->                                    -- _obj+    b ->                                    -- certificate+    Maybe (c) ->                            -- interaction+    TlsDatabaseLookupFlags ->               -- flags+    Maybe (d) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+tlsDatabaseLookupCertificateIssuerAsync _obj certificate interaction flags cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let certificate' = unsafeManagedPtrCastPtr certificate+    maybeInteraction <- case interaction of+        Nothing -> return nullPtr+        Just jInteraction -> do+            let jInteraction' = unsafeManagedPtrCastPtr jInteraction+            return jInteraction'+    let flags' = (fromIntegral . fromEnum) flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_tls_database_lookup_certificate_issuer_async _obj' certificate' maybeInteraction flags' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    touchManagedPtr certificate+    whenJust interaction touchManagedPtr+    whenJust cancellable touchManagedPtr+    return ()++-- method TlsDatabase::lookup_certificate_issuer_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsDatabase", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsDatabase", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TlsCertificate"+-- throws : True+-- Skip return : False++foreign import ccall "g_tls_database_lookup_certificate_issuer_finish" g_tls_database_lookup_certificate_issuer_finish :: +    Ptr TlsDatabase ->                      -- _obj : TInterface "Gio" "TlsDatabase"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr TlsCertificate)+++tlsDatabaseLookupCertificateIssuerFinish ::+    (MonadIO m, TlsDatabaseK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m TlsCertificate+tlsDatabaseLookupCertificateIssuerFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        result <- propagateGError $ g_tls_database_lookup_certificate_issuer_finish _obj' result_'+        checkUnexpectedReturnNULL "g_tls_database_lookup_certificate_issuer_finish" result+        result' <- (wrapObject TlsCertificate) result+        touchManagedPtr _obj+        touchManagedPtr result_+        return result'+     ) (do+        return ()+     )++-- method TlsDatabase::lookup_certificates_issued_by+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsDatabase", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "issuer_raw_dn", argType = TByteArray, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interaction", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "TlsDatabaseLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsDatabase", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "issuer_raw_dn", argType = TByteArray, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interaction", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "TlsDatabaseLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gio" "TlsCertificate")+-- throws : True+-- Skip return : False++foreign import ccall "g_tls_database_lookup_certificates_issued_by" g_tls_database_lookup_certificates_issued_by :: +    Ptr TlsDatabase ->                      -- _obj : TInterface "Gio" "TlsDatabase"+    Ptr GByteArray ->                       -- issuer_raw_dn : TByteArray+    Ptr TlsInteraction ->                   -- interaction : TInterface "Gio" "TlsInteraction"+    CUInt ->                                -- flags : TInterface "Gio" "TlsDatabaseLookupFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr (GList (Ptr TlsCertificate)))+++tlsDatabaseLookupCertificatesIssuedBy ::+    (MonadIO m, TlsDatabaseK a, TlsInteractionK b, CancellableK c) =>+    a ->                                    -- _obj+    ByteString ->                           -- issuer_raw_dn+    Maybe (b) ->                            -- interaction+    TlsDatabaseLookupFlags ->               -- flags+    Maybe (c) ->                            -- cancellable+    m [TlsCertificate]+tlsDatabaseLookupCertificatesIssuedBy _obj issuer_raw_dn interaction flags cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    issuer_raw_dn' <- packGByteArray issuer_raw_dn+    maybeInteraction <- case interaction of+        Nothing -> return nullPtr+        Just jInteraction -> do+            let jInteraction' = unsafeManagedPtrCastPtr jInteraction+            return jInteraction'+    let flags' = (fromIntegral . fromEnum) flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_tls_database_lookup_certificates_issued_by _obj' issuer_raw_dn' maybeInteraction flags' maybeCancellable+        checkUnexpectedReturnNULL "g_tls_database_lookup_certificates_issued_by" result+        result' <- unpackGList result+        result'' <- mapM (wrapObject TlsCertificate) result'+        g_list_free result+        touchManagedPtr _obj+        whenJust interaction touchManagedPtr+        whenJust cancellable touchManagedPtr+        unrefGByteArray issuer_raw_dn'+        return result''+     ) (do+        unrefGByteArray issuer_raw_dn'+     )++-- method TlsDatabase::lookup_certificates_issued_by_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsDatabase", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "issuer_raw_dn", argType = TByteArray, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interaction", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "TlsDatabaseLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsDatabase", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "issuer_raw_dn", argType = TByteArray, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interaction", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "TlsDatabaseLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_database_lookup_certificates_issued_by_async" g_tls_database_lookup_certificates_issued_by_async :: +    Ptr TlsDatabase ->                      -- _obj : TInterface "Gio" "TlsDatabase"+    Ptr GByteArray ->                       -- issuer_raw_dn : TByteArray+    Ptr TlsInteraction ->                   -- interaction : TInterface "Gio" "TlsInteraction"+    CUInt ->                                -- flags : TInterface "Gio" "TlsDatabaseLookupFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++tlsDatabaseLookupCertificatesIssuedByAsync ::+    (MonadIO m, TlsDatabaseK a, TlsInteractionK b, CancellableK c) =>+    a ->                                    -- _obj+    ByteString ->                           -- issuer_raw_dn+    Maybe (b) ->                            -- interaction+    TlsDatabaseLookupFlags ->               -- flags+    Maybe (c) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+tlsDatabaseLookupCertificatesIssuedByAsync _obj issuer_raw_dn interaction flags cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    issuer_raw_dn' <- packGByteArray issuer_raw_dn+    maybeInteraction <- case interaction of+        Nothing -> return nullPtr+        Just jInteraction -> do+            let jInteraction' = unsafeManagedPtrCastPtr jInteraction+            return jInteraction'+    let flags' = (fromIntegral . fromEnum) flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_tls_database_lookup_certificates_issued_by_async _obj' issuer_raw_dn' maybeInteraction flags' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust interaction touchManagedPtr+    whenJust cancellable touchManagedPtr+    unrefGByteArray issuer_raw_dn'+    return ()++-- method TlsDatabase::lookup_certificates_issued_by_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsDatabase", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsDatabase", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gio" "TlsCertificate")+-- throws : True+-- Skip return : False++foreign import ccall "g_tls_database_lookup_certificates_issued_by_finish" g_tls_database_lookup_certificates_issued_by_finish :: +    Ptr TlsDatabase ->                      -- _obj : TInterface "Gio" "TlsDatabase"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr (GList (Ptr TlsCertificate)))+++tlsDatabaseLookupCertificatesIssuedByFinish ::+    (MonadIO m, TlsDatabaseK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m [TlsCertificate]+tlsDatabaseLookupCertificatesIssuedByFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        result <- propagateGError $ g_tls_database_lookup_certificates_issued_by_finish _obj' result_'+        checkUnexpectedReturnNULL "g_tls_database_lookup_certificates_issued_by_finish" result+        result' <- unpackGList result+        result'' <- mapM (wrapObject TlsCertificate) result'+        g_list_free result+        touchManagedPtr _obj+        touchManagedPtr result_+        return result''+     ) (do+        return ()+     )++-- method TlsDatabase::verify_chain+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsDatabase", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "chain", argType = TInterface "Gio" "TlsCertificate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "purpose", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "identity", argType = TInterface "Gio" "SocketConnectable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interaction", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "TlsDatabaseVerifyFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsDatabase", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "chain", argType = TInterface "Gio" "TlsCertificate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "purpose", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "identity", argType = TInterface "Gio" "SocketConnectable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interaction", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "TlsDatabaseVerifyFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TlsCertificateFlags"+-- throws : True+-- Skip return : False++foreign import ccall "g_tls_database_verify_chain" g_tls_database_verify_chain :: +    Ptr TlsDatabase ->                      -- _obj : TInterface "Gio" "TlsDatabase"+    Ptr TlsCertificate ->                   -- chain : TInterface "Gio" "TlsCertificate"+    CString ->                              -- purpose : TBasicType TUTF8+    Ptr SocketConnectable ->                -- identity : TInterface "Gio" "SocketConnectable"+    Ptr TlsInteraction ->                   -- interaction : TInterface "Gio" "TlsInteraction"+    CUInt ->                                -- flags : TInterface "Gio" "TlsDatabaseVerifyFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CUInt+++tlsDatabaseVerifyChain ::+    (MonadIO m, TlsDatabaseK a, TlsCertificateK b, SocketConnectableK c, TlsInteractionK d, CancellableK e) =>+    a ->                                    -- _obj+    b ->                                    -- chain+    T.Text ->                               -- purpose+    Maybe (c) ->                            -- identity+    Maybe (d) ->                            -- interaction+    [TlsDatabaseVerifyFlags] ->             -- flags+    Maybe (e) ->                            -- cancellable+    m [TlsCertificateFlags]+tlsDatabaseVerifyChain _obj chain purpose identity interaction flags cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let chain' = unsafeManagedPtrCastPtr chain+    purpose' <- textToCString purpose+    maybeIdentity <- case identity of+        Nothing -> return nullPtr+        Just jIdentity -> do+            let jIdentity' = unsafeManagedPtrCastPtr jIdentity+            return jIdentity'+    maybeInteraction <- case interaction of+        Nothing -> return nullPtr+        Just jInteraction -> do+            let jInteraction' = unsafeManagedPtrCastPtr jInteraction+            return jInteraction'+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_tls_database_verify_chain _obj' chain' purpose' maybeIdentity maybeInteraction flags' maybeCancellable+        let result' = wordToGFlags result+        touchManagedPtr _obj+        touchManagedPtr chain+        whenJust identity touchManagedPtr+        whenJust interaction touchManagedPtr+        whenJust cancellable touchManagedPtr+        freeMem purpose'+        return result'+     ) (do+        freeMem purpose'+     )++-- method TlsDatabase::verify_chain_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsDatabase", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "chain", argType = TInterface "Gio" "TlsCertificate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "purpose", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "identity", argType = TInterface "Gio" "SocketConnectable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interaction", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "TlsDatabaseVerifyFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 8, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsDatabase", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "chain", argType = TInterface "Gio" "TlsCertificate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "purpose", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "identity", argType = TInterface "Gio" "SocketConnectable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "interaction", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "TlsDatabaseVerifyFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 8, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_database_verify_chain_async" g_tls_database_verify_chain_async :: +    Ptr TlsDatabase ->                      -- _obj : TInterface "Gio" "TlsDatabase"+    Ptr TlsCertificate ->                   -- chain : TInterface "Gio" "TlsCertificate"+    CString ->                              -- purpose : TBasicType TUTF8+    Ptr SocketConnectable ->                -- identity : TInterface "Gio" "SocketConnectable"+    Ptr TlsInteraction ->                   -- interaction : TInterface "Gio" "TlsInteraction"+    CUInt ->                                -- flags : TInterface "Gio" "TlsDatabaseVerifyFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++tlsDatabaseVerifyChainAsync ::+    (MonadIO m, TlsDatabaseK a, TlsCertificateK b, SocketConnectableK c, TlsInteractionK d, CancellableK e) =>+    a ->                                    -- _obj+    b ->                                    -- chain+    T.Text ->                               -- purpose+    Maybe (c) ->                            -- identity+    Maybe (d) ->                            -- interaction+    [TlsDatabaseVerifyFlags] ->             -- flags+    Maybe (e) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+tlsDatabaseVerifyChainAsync _obj chain purpose identity interaction flags cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let chain' = unsafeManagedPtrCastPtr chain+    purpose' <- textToCString purpose+    maybeIdentity <- case identity of+        Nothing -> return nullPtr+        Just jIdentity -> do+            let jIdentity' = unsafeManagedPtrCastPtr jIdentity+            return jIdentity'+    maybeInteraction <- case interaction of+        Nothing -> return nullPtr+        Just jInteraction -> do+            let jInteraction' = unsafeManagedPtrCastPtr jInteraction+            return jInteraction'+    let flags' = gflagsToWord flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_tls_database_verify_chain_async _obj' chain' purpose' maybeIdentity maybeInteraction flags' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    touchManagedPtr chain+    whenJust identity touchManagedPtr+    whenJust interaction touchManagedPtr+    whenJust cancellable touchManagedPtr+    freeMem purpose'+    return ()++-- method TlsDatabase::verify_chain_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsDatabase", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsDatabase", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TlsCertificateFlags"+-- throws : True+-- Skip return : False++foreign import ccall "g_tls_database_verify_chain_finish" g_tls_database_verify_chain_finish :: +    Ptr TlsDatabase ->                      -- _obj : TInterface "Gio" "TlsDatabase"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CUInt+++tlsDatabaseVerifyChainFinish ::+    (MonadIO m, TlsDatabaseK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m [TlsCertificateFlags]+tlsDatabaseVerifyChainFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        result <- propagateGError $ g_tls_database_verify_chain_finish _obj' result_'+        let result' = wordToGFlags result+        touchManagedPtr _obj+        touchManagedPtr result_+        return result'+     ) (do+        return ()+     )++
+ GI/Gio/Objects/TlsDatabase.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Objects.TlsDatabase where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype TlsDatabase = TlsDatabase (ForeignPtr TlsDatabase)+instance GObject TlsDatabase where+class GObject o => TlsDatabaseK o+instance (GObject o, IsDescendantOf TlsDatabase o) => TlsDatabaseK o
+ GI/Gio/Objects/TlsInteraction.hs view
@@ -0,0 +1,432 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.TlsInteraction+    ( ++-- * Exported types+    TlsInteraction(..)                      ,+    TlsInteractionK                         ,+    toTlsInteraction                        ,+    noTlsInteraction                        ,+++ -- * Methods+-- ** tlsInteractionAskPassword+    tlsInteractionAskPassword               ,+++-- ** tlsInteractionAskPasswordAsync+    tlsInteractionAskPasswordAsync          ,+++-- ** tlsInteractionAskPasswordFinish+    tlsInteractionAskPasswordFinish         ,+++-- ** tlsInteractionInvokeAskPassword+    tlsInteractionInvokeAskPassword         ,+++-- ** tlsInteractionInvokeRequestCertificate+    tlsInteractionInvokeRequestCertificate  ,+++-- ** tlsInteractionRequestCertificate+    tlsInteractionRequestCertificate        ,+++-- ** tlsInteractionRequestCertificateAsync+    tlsInteractionRequestCertificateAsync   ,+++-- ** tlsInteractionRequestCertificateFinish+    tlsInteractionRequestCertificateFinish  ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype TlsInteraction = TlsInteraction (ForeignPtr TlsInteraction)+foreign import ccall "g_tls_interaction_get_type"+    c_g_tls_interaction_get_type :: IO GType++type instance ParentTypes TlsInteraction = TlsInteractionParentTypes+type TlsInteractionParentTypes = '[GObject.Object]++instance GObject TlsInteraction where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_tls_interaction_get_type+    ++class GObject o => TlsInteractionK o+instance (GObject o, IsDescendantOf TlsInteraction o) => TlsInteractionK o++toTlsInteraction :: TlsInteractionK o => o -> IO TlsInteraction+toTlsInteraction = unsafeCastTo TlsInteraction++noTlsInteraction :: Maybe TlsInteraction+noTlsInteraction = Nothing++type instance AttributeList TlsInteraction = TlsInteractionAttributeList+type TlsInteractionAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList TlsInteraction = TlsInteractionSignalList+type TlsInteractionSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method TlsInteraction::ask_password+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "password", argType = TInterface "Gio" "TlsPassword", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "password", argType = TInterface "Gio" "TlsPassword", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TlsInteractionResult"+-- throws : True+-- Skip return : False++foreign import ccall "g_tls_interaction_ask_password" g_tls_interaction_ask_password :: +    Ptr TlsInteraction ->                   -- _obj : TInterface "Gio" "TlsInteraction"+    Ptr TlsPassword ->                      -- password : TInterface "Gio" "TlsPassword"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CUInt+++tlsInteractionAskPassword ::+    (MonadIO m, TlsInteractionK a, TlsPasswordK b, CancellableK c) =>+    a ->                                    -- _obj+    b ->                                    -- password+    Maybe (c) ->                            -- cancellable+    m TlsInteractionResult+tlsInteractionAskPassword _obj password cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let password' = unsafeManagedPtrCastPtr password+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_tls_interaction_ask_password _obj' password' maybeCancellable+        let result' = (toEnum . fromIntegral) result+        touchManagedPtr _obj+        touchManagedPtr password+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )++-- method TlsInteraction::ask_password_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "password", argType = TInterface "Gio" "TlsPassword", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "password", argType = TInterface "Gio" "TlsPassword", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_interaction_ask_password_async" g_tls_interaction_ask_password_async :: +    Ptr TlsInteraction ->                   -- _obj : TInterface "Gio" "TlsInteraction"+    Ptr TlsPassword ->                      -- password : TInterface "Gio" "TlsPassword"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++tlsInteractionAskPasswordAsync ::+    (MonadIO m, TlsInteractionK a, TlsPasswordK b, CancellableK c) =>+    a ->                                    -- _obj+    b ->                                    -- password+    Maybe (c) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+tlsInteractionAskPasswordAsync _obj password cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let password' = unsafeManagedPtrCastPtr password+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_tls_interaction_ask_password_async _obj' password' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    touchManagedPtr password+    whenJust cancellable touchManagedPtr+    return ()++-- method TlsInteraction::ask_password_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TlsInteractionResult"+-- throws : True+-- Skip return : False++foreign import ccall "g_tls_interaction_ask_password_finish" g_tls_interaction_ask_password_finish :: +    Ptr TlsInteraction ->                   -- _obj : TInterface "Gio" "TlsInteraction"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CUInt+++tlsInteractionAskPasswordFinish ::+    (MonadIO m, TlsInteractionK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m TlsInteractionResult+tlsInteractionAskPasswordFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        result <- propagateGError $ g_tls_interaction_ask_password_finish _obj' result_'+        let result' = (toEnum . fromIntegral) result+        touchManagedPtr _obj+        touchManagedPtr result_+        return result'+     ) (do+        return ()+     )++-- method TlsInteraction::invoke_ask_password+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "password", argType = TInterface "Gio" "TlsPassword", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "password", argType = TInterface "Gio" "TlsPassword", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TlsInteractionResult"+-- throws : True+-- Skip return : False++foreign import ccall "g_tls_interaction_invoke_ask_password" g_tls_interaction_invoke_ask_password :: +    Ptr TlsInteraction ->                   -- _obj : TInterface "Gio" "TlsInteraction"+    Ptr TlsPassword ->                      -- password : TInterface "Gio" "TlsPassword"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CUInt+++tlsInteractionInvokeAskPassword ::+    (MonadIO m, TlsInteractionK a, TlsPasswordK b, CancellableK c) =>+    a ->                                    -- _obj+    b ->                                    -- password+    Maybe (c) ->                            -- cancellable+    m TlsInteractionResult+tlsInteractionInvokeAskPassword _obj password cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let password' = unsafeManagedPtrCastPtr password+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_tls_interaction_invoke_ask_password _obj' password' maybeCancellable+        let result' = (toEnum . fromIntegral) result+        touchManagedPtr _obj+        touchManagedPtr password+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )++-- method TlsInteraction::invoke_request_certificate+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "connection", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "TlsCertificateRequestFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "connection", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "TlsCertificateRequestFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TlsInteractionResult"+-- throws : True+-- Skip return : False++foreign import ccall "g_tls_interaction_invoke_request_certificate" g_tls_interaction_invoke_request_certificate :: +    Ptr TlsInteraction ->                   -- _obj : TInterface "Gio" "TlsInteraction"+    Ptr TlsConnection ->                    -- connection : TInterface "Gio" "TlsConnection"+    CUInt ->                                -- flags : TInterface "Gio" "TlsCertificateRequestFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CUInt+++tlsInteractionInvokeRequestCertificate ::+    (MonadIO m, TlsInteractionK a, TlsConnectionK b, CancellableK c) =>+    a ->                                    -- _obj+    b ->                                    -- connection+    TlsCertificateRequestFlags ->           -- flags+    Maybe (c) ->                            -- cancellable+    m TlsInteractionResult+tlsInteractionInvokeRequestCertificate _obj connection flags cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let connection' = unsafeManagedPtrCastPtr connection+    let flags' = (fromIntegral . fromEnum) flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_tls_interaction_invoke_request_certificate _obj' connection' flags' maybeCancellable+        let result' = (toEnum . fromIntegral) result+        touchManagedPtr _obj+        touchManagedPtr connection+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )++-- method TlsInteraction::request_certificate+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "connection", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "TlsCertificateRequestFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "connection", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "TlsCertificateRequestFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TlsInteractionResult"+-- throws : True+-- Skip return : False++foreign import ccall "g_tls_interaction_request_certificate" g_tls_interaction_request_certificate :: +    Ptr TlsInteraction ->                   -- _obj : TInterface "Gio" "TlsInteraction"+    Ptr TlsConnection ->                    -- connection : TInterface "Gio" "TlsConnection"+    CUInt ->                                -- flags : TInterface "Gio" "TlsCertificateRequestFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CUInt+++tlsInteractionRequestCertificate ::+    (MonadIO m, TlsInteractionK a, TlsConnectionK b, CancellableK c) =>+    a ->                                    -- _obj+    b ->                                    -- connection+    TlsCertificateRequestFlags ->           -- flags+    Maybe (c) ->                            -- cancellable+    m TlsInteractionResult+tlsInteractionRequestCertificate _obj connection flags cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let connection' = unsafeManagedPtrCastPtr connection+    let flags' = (fromIntegral . fromEnum) flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_tls_interaction_request_certificate _obj' connection' flags' maybeCancellable+        let result' = (toEnum . fromIntegral) result+        touchManagedPtr _obj+        touchManagedPtr connection+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )++-- method TlsInteraction::request_certificate_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "connection", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "TlsCertificateRequestFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "connection", argType = TInterface "Gio" "TlsConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "TlsCertificateRequestFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_interaction_request_certificate_async" g_tls_interaction_request_certificate_async :: +    Ptr TlsInteraction ->                   -- _obj : TInterface "Gio" "TlsInteraction"+    Ptr TlsConnection ->                    -- connection : TInterface "Gio" "TlsConnection"+    CUInt ->                                -- flags : TInterface "Gio" "TlsCertificateRequestFlags"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++tlsInteractionRequestCertificateAsync ::+    (MonadIO m, TlsInteractionK a, TlsConnectionK b, CancellableK c) =>+    a ->                                    -- _obj+    b ->                                    -- connection+    TlsCertificateRequestFlags ->           -- flags+    Maybe (c) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+tlsInteractionRequestCertificateAsync _obj connection flags cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let connection' = unsafeManagedPtrCastPtr connection+    let flags' = (fromIntegral . fromEnum) flags+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_tls_interaction_request_certificate_async _obj' connection' flags' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    touchManagedPtr connection+    whenJust cancellable touchManagedPtr+    return ()++-- method TlsInteraction::request_certificate_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsInteraction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TlsInteractionResult"+-- throws : True+-- Skip return : False++foreign import ccall "g_tls_interaction_request_certificate_finish" g_tls_interaction_request_certificate_finish :: +    Ptr TlsInteraction ->                   -- _obj : TInterface "Gio" "TlsInteraction"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CUInt+++tlsInteractionRequestCertificateFinish ::+    (MonadIO m, TlsInteractionK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m TlsInteractionResult+tlsInteractionRequestCertificateFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        result <- propagateGError $ g_tls_interaction_request_certificate_finish _obj' result_'+        let result' = (toEnum . fromIntegral) result+        touchManagedPtr _obj+        touchManagedPtr result_+        return result'+     ) (do+        return ()+     )++
+ GI/Gio/Objects/TlsInteraction.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Objects.TlsInteraction where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype TlsInteraction = TlsInteraction (ForeignPtr TlsInteraction)+instance GObject TlsInteraction where+class GObject o => TlsInteractionK o+instance (GObject o, IsDescendantOf TlsInteraction o) => TlsInteractionK o
+ GI/Gio/Objects/TlsPassword.hs view
@@ -0,0 +1,448 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.TlsPassword+    ( ++-- * Exported types+    TlsPassword(..)                         ,+    TlsPasswordK                            ,+    toTlsPassword                           ,+    noTlsPassword                           ,+++ -- * Methods+-- ** tlsPasswordGetDescription+    tlsPasswordGetDescription               ,+++-- ** tlsPasswordGetFlags+    tlsPasswordGetFlags                     ,+++-- ** tlsPasswordGetWarning+    tlsPasswordGetWarning                   ,+++-- ** tlsPasswordNew+    tlsPasswordNew                          ,+++-- ** tlsPasswordSetDescription+    tlsPasswordSetDescription               ,+++-- ** tlsPasswordSetFlags+    tlsPasswordSetFlags                     ,+++-- ** tlsPasswordSetValue+    tlsPasswordSetValue                     ,+++-- ** tlsPasswordSetValueFull+    tlsPasswordSetValueFull                 ,+++-- ** tlsPasswordSetWarning+    tlsPasswordSetWarning                   ,+++++ -- * Properties+-- ** Description+    TlsPasswordDescriptionPropertyInfo      ,+    constructTlsPasswordDescription         ,+    getTlsPasswordDescription               ,+    setTlsPasswordDescription               ,+++-- ** Flags+    TlsPasswordFlagsPropertyInfo            ,+    constructTlsPasswordFlags               ,+    getTlsPasswordFlags                     ,+    setTlsPasswordFlags                     ,+++-- ** Warning+    TlsPasswordWarningPropertyInfo          ,+    constructTlsPasswordWarning             ,+    getTlsPasswordWarning                   ,+    setTlsPasswordWarning                   ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype TlsPassword = TlsPassword (ForeignPtr TlsPassword)+foreign import ccall "g_tls_password_get_type"+    c_g_tls_password_get_type :: IO GType++type instance ParentTypes TlsPassword = TlsPasswordParentTypes+type TlsPasswordParentTypes = '[GObject.Object]++instance GObject TlsPassword where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_tls_password_get_type+    ++class GObject o => TlsPasswordK o+instance (GObject o, IsDescendantOf TlsPassword o) => TlsPasswordK o++toTlsPassword :: TlsPasswordK o => o -> IO TlsPassword+toTlsPassword = unsafeCastTo TlsPassword++noTlsPassword :: Maybe TlsPassword+noTlsPassword = Nothing++-- VVV Prop "description"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getTlsPasswordDescription :: (MonadIO m, TlsPasswordK o) => o -> m T.Text+getTlsPasswordDescription obj = liftIO $ getObjectPropertyString obj "description"++setTlsPasswordDescription :: (MonadIO m, TlsPasswordK o) => o -> T.Text -> m ()+setTlsPasswordDescription obj val = liftIO $ setObjectPropertyString obj "description" val++constructTlsPasswordDescription :: T.Text -> IO ([Char], GValue)+constructTlsPasswordDescription val = constructObjectPropertyString "description" val++data TlsPasswordDescriptionPropertyInfo+instance AttrInfo TlsPasswordDescriptionPropertyInfo where+    type AttrAllowedOps TlsPasswordDescriptionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TlsPasswordDescriptionPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint TlsPasswordDescriptionPropertyInfo = TlsPasswordK+    type AttrGetType TlsPasswordDescriptionPropertyInfo = T.Text+    type AttrLabel TlsPasswordDescriptionPropertyInfo = "TlsPassword::description"+    attrGet _ = getTlsPasswordDescription+    attrSet _ = setTlsPasswordDescription+    attrConstruct _ = constructTlsPasswordDescription++-- VVV Prop "flags"+   -- Type: TInterface "Gio" "TlsPasswordFlags"+   -- Flags: [PropertyReadable,PropertyWritable]++getTlsPasswordFlags :: (MonadIO m, TlsPasswordK o) => o -> m [TlsPasswordFlags]+getTlsPasswordFlags obj = liftIO $ getObjectPropertyFlags obj "flags"++setTlsPasswordFlags :: (MonadIO m, TlsPasswordK o) => o -> [TlsPasswordFlags] -> m ()+setTlsPasswordFlags obj val = liftIO $ setObjectPropertyFlags obj "flags" val++constructTlsPasswordFlags :: [TlsPasswordFlags] -> IO ([Char], GValue)+constructTlsPasswordFlags val = constructObjectPropertyFlags "flags" val++data TlsPasswordFlagsPropertyInfo+instance AttrInfo TlsPasswordFlagsPropertyInfo where+    type AttrAllowedOps TlsPasswordFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TlsPasswordFlagsPropertyInfo = (~) [TlsPasswordFlags]+    type AttrBaseTypeConstraint TlsPasswordFlagsPropertyInfo = TlsPasswordK+    type AttrGetType TlsPasswordFlagsPropertyInfo = [TlsPasswordFlags]+    type AttrLabel TlsPasswordFlagsPropertyInfo = "TlsPassword::flags"+    attrGet _ = getTlsPasswordFlags+    attrSet _ = setTlsPasswordFlags+    attrConstruct _ = constructTlsPasswordFlags++-- VVV Prop "warning"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getTlsPasswordWarning :: (MonadIO m, TlsPasswordK o) => o -> m T.Text+getTlsPasswordWarning obj = liftIO $ getObjectPropertyString obj "warning"++setTlsPasswordWarning :: (MonadIO m, TlsPasswordK o) => o -> T.Text -> m ()+setTlsPasswordWarning obj val = liftIO $ setObjectPropertyString obj "warning" val++constructTlsPasswordWarning :: T.Text -> IO ([Char], GValue)+constructTlsPasswordWarning val = constructObjectPropertyString "warning" val++data TlsPasswordWarningPropertyInfo+instance AttrInfo TlsPasswordWarningPropertyInfo where+    type AttrAllowedOps TlsPasswordWarningPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint TlsPasswordWarningPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint TlsPasswordWarningPropertyInfo = TlsPasswordK+    type AttrGetType TlsPasswordWarningPropertyInfo = T.Text+    type AttrLabel TlsPasswordWarningPropertyInfo = "TlsPassword::warning"+    attrGet _ = getTlsPasswordWarning+    attrSet _ = setTlsPasswordWarning+    attrConstruct _ = constructTlsPasswordWarning++type instance AttributeList TlsPassword = TlsPasswordAttributeList+type TlsPasswordAttributeList = ('[ '("description", TlsPasswordDescriptionPropertyInfo), '("flags", TlsPasswordFlagsPropertyInfo), '("warning", TlsPasswordWarningPropertyInfo)] :: [(Symbol, *)])++type instance SignalList TlsPassword = TlsPasswordSignalList+type TlsPasswordSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method TlsPassword::new+-- method type : Constructor+-- Args : [Arg {argName = "flags", argType = TInterface "Gio" "TlsPasswordFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "description", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "flags", argType = TInterface "Gio" "TlsPasswordFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "description", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TlsPassword"+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_password_new" g_tls_password_new :: +    CUInt ->                                -- flags : TInterface "Gio" "TlsPasswordFlags"+    CString ->                              -- description : TBasicType TUTF8+    IO (Ptr TlsPassword)+++tlsPasswordNew ::+    (MonadIO m) =>+    [TlsPasswordFlags] ->                   -- flags+    T.Text ->                               -- description+    m TlsPassword+tlsPasswordNew flags description = liftIO $ do+    let flags' = gflagsToWord flags+    description' <- textToCString description+    result <- g_tls_password_new flags' description'+    checkUnexpectedReturnNULL "g_tls_password_new" result+    result' <- (wrapObject TlsPassword) result+    freeMem description'+    return result'++-- method TlsPassword::get_description+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsPassword", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsPassword", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_password_get_description" g_tls_password_get_description :: +    Ptr TlsPassword ->                      -- _obj : TInterface "Gio" "TlsPassword"+    IO CString+++tlsPasswordGetDescription ::+    (MonadIO m, TlsPasswordK a) =>+    a ->                                    -- _obj+    m T.Text+tlsPasswordGetDescription _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_tls_password_get_description _obj'+    checkUnexpectedReturnNULL "g_tls_password_get_description" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method TlsPassword::get_flags+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsPassword", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsPassword", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "TlsPasswordFlags"+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_password_get_flags" g_tls_password_get_flags :: +    Ptr TlsPassword ->                      -- _obj : TInterface "Gio" "TlsPassword"+    IO CUInt+++tlsPasswordGetFlags ::+    (MonadIO m, TlsPasswordK a) =>+    a ->                                    -- _obj+    m [TlsPasswordFlags]+tlsPasswordGetFlags _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_tls_password_get_flags _obj'+    let result' = wordToGFlags result+    touchManagedPtr _obj+    return result'++-- method TlsPassword::get_warning+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsPassword", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsPassword", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_password_get_warning" g_tls_password_get_warning :: +    Ptr TlsPassword ->                      -- _obj : TInterface "Gio" "TlsPassword"+    IO CString+++tlsPasswordGetWarning ::+    (MonadIO m, TlsPasswordK a) =>+    a ->                                    -- _obj+    m T.Text+tlsPasswordGetWarning _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_tls_password_get_warning _obj'+    checkUnexpectedReturnNULL "g_tls_password_get_warning" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method TlsPassword::set_description+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsPassword", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "description", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsPassword", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "description", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_password_set_description" g_tls_password_set_description :: +    Ptr TlsPassword ->                      -- _obj : TInterface "Gio" "TlsPassword"+    CString ->                              -- description : TBasicType TUTF8+    IO ()+++tlsPasswordSetDescription ::+    (MonadIO m, TlsPasswordK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- description+    m ()+tlsPasswordSetDescription _obj description = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    description' <- textToCString description+    g_tls_password_set_description _obj' description'+    touchManagedPtr _obj+    freeMem description'+    return ()++-- method TlsPassword::set_flags+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsPassword", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "TlsPasswordFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsPassword", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "TlsPasswordFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_password_set_flags" g_tls_password_set_flags :: +    Ptr TlsPassword ->                      -- _obj : TInterface "Gio" "TlsPassword"+    CUInt ->                                -- flags : TInterface "Gio" "TlsPasswordFlags"+    IO ()+++tlsPasswordSetFlags ::+    (MonadIO m, TlsPasswordK a) =>+    a ->                                    -- _obj+    [TlsPasswordFlags] ->                   -- flags+    m ()+tlsPasswordSetFlags _obj flags = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    g_tls_password_set_flags _obj' flags'+    touchManagedPtr _obj+    return ()++-- method TlsPassword::set_value+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsPassword", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUInt8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsPassword", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUInt8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_password_set_value" g_tls_password_set_value :: +    Ptr TlsPassword ->                      -- _obj : TInterface "Gio" "TlsPassword"+    Word8 ->                                -- value : TBasicType TUInt8+    Int64 ->                                -- length : TBasicType TInt64+    IO ()+++tlsPasswordSetValue ::+    (MonadIO m, TlsPasswordK a) =>+    a ->                                    -- _obj+    Word8 ->                                -- value+    Int64 ->                                -- length+    m ()+tlsPasswordSetValue _obj value length_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_tls_password_set_value _obj' value length_+    touchManagedPtr _obj+    return ()++-- method TlsPassword::set_value_full+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsPassword", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUInt8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "destroy", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsPassword", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TBasicType TUInt8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "destroy", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_password_set_value_full" g_tls_password_set_value_full :: +    Ptr TlsPassword ->                      -- _obj : TInterface "Gio" "TlsPassword"+    Word8 ->                                -- value : TBasicType TUInt8+    Int64 ->                                -- length : TBasicType TInt64+    FunPtr GLib.DestroyNotifyC ->           -- destroy : TInterface "GLib" "DestroyNotify"+    IO ()+++tlsPasswordSetValueFull ::+    (MonadIO m, TlsPasswordK a) =>+    a ->                                    -- _obj+    Word8 ->                                -- value+    Int64 ->                                -- length+    Maybe (GLib.DestroyNotify) ->           -- destroy+    m ()+tlsPasswordSetValueFull _obj value length_ destroy = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    ptrdestroy <- callocMem :: IO (Ptr (FunPtr GLib.DestroyNotifyC))+    maybeDestroy <- case destroy of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jDestroy -> do+            jDestroy' <- GLib.mkDestroyNotify (GLib.destroyNotifyWrapper (Just ptrdestroy) jDestroy)+            poke ptrdestroy jDestroy'+            return jDestroy'+    g_tls_password_set_value_full _obj' value length_ maybeDestroy+    touchManagedPtr _obj+    return ()++-- method TlsPassword::set_warning+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsPassword", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "warning", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "TlsPassword", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "warning", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_tls_password_set_warning" g_tls_password_set_warning :: +    Ptr TlsPassword ->                      -- _obj : TInterface "Gio" "TlsPassword"+    CString ->                              -- warning : TBasicType TUTF8+    IO ()+++tlsPasswordSetWarning ::+    (MonadIO m, TlsPasswordK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- warning+    m ()+tlsPasswordSetWarning _obj warning = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    warning' <- textToCString warning+    g_tls_password_set_warning _obj' warning'+    touchManagedPtr _obj+    freeMem warning'+    return ()++
+ GI/Gio/Objects/TlsPassword.hs-boot view
@@ -0,0 +1,16 @@+module GI.Gio.Objects.TlsPassword where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype TlsPassword = TlsPassword (ForeignPtr TlsPassword)+instance GObject TlsPassword where+class GObject o => TlsPasswordK o+instance (GObject o, IsDescendantOf TlsPassword o) => TlsPasswordK o+data TlsPasswordDescriptionPropertyInfo+data TlsPasswordFlagsPropertyInfo+data TlsPasswordWarningPropertyInfo
+ GI/Gio/Objects/UnixConnection.hs view
@@ -0,0 +1,399 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.UnixConnection+    ( ++-- * Exported types+    UnixConnection(..)                      ,+    UnixConnectionK                         ,+    toUnixConnection                        ,+    noUnixConnection                        ,+++ -- * Methods+-- ** unixConnectionReceiveCredentials+    unixConnectionReceiveCredentials        ,+++-- ** unixConnectionReceiveCredentialsAsync+    unixConnectionReceiveCredentialsAsync   ,+++-- ** unixConnectionReceiveCredentialsFinish+    unixConnectionReceiveCredentialsFinish  ,+++-- ** unixConnectionReceiveFd+    unixConnectionReceiveFd                 ,+++-- ** unixConnectionSendCredentials+    unixConnectionSendCredentials           ,+++-- ** unixConnectionSendCredentialsAsync+    unixConnectionSendCredentialsAsync      ,+++-- ** unixConnectionSendCredentialsFinish+    unixConnectionSendCredentialsFinish     ,+++-- ** unixConnectionSendFd+    unixConnectionSendFd                    ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype UnixConnection = UnixConnection (ForeignPtr UnixConnection)+foreign import ccall "g_unix_connection_get_type"+    c_g_unix_connection_get_type :: IO GType++type instance ParentTypes UnixConnection = UnixConnectionParentTypes+type UnixConnectionParentTypes = '[SocketConnection, IOStream, GObject.Object]++instance GObject UnixConnection where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_unix_connection_get_type+    ++class GObject o => UnixConnectionK o+instance (GObject o, IsDescendantOf UnixConnection o) => UnixConnectionK o++toUnixConnection :: UnixConnectionK o => o -> IO UnixConnection+toUnixConnection = unsafeCastTo UnixConnection++noUnixConnection :: Maybe UnixConnection+noUnixConnection = Nothing++type instance AttributeList UnixConnection = UnixConnectionAttributeList+type UnixConnectionAttributeList = ('[ '("closed", IOStreamClosedPropertyInfo), '("input-stream", IOStreamInputStreamPropertyInfo), '("output-stream", IOStreamOutputStreamPropertyInfo), '("socket", SocketConnectionSocketPropertyInfo)] :: [(Symbol, *)])++type instance SignalList UnixConnection = UnixConnectionSignalList+type UnixConnectionSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method UnixConnection::receive_credentials+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Credentials"+-- throws : True+-- Skip return : False++foreign import ccall "g_unix_connection_receive_credentials" g_unix_connection_receive_credentials :: +    Ptr UnixConnection ->                   -- _obj : TInterface "Gio" "UnixConnection"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Credentials)+++unixConnectionReceiveCredentials ::+    (MonadIO m, UnixConnectionK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m Credentials+unixConnectionReceiveCredentials _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_unix_connection_receive_credentials _obj' maybeCancellable+        checkUnexpectedReturnNULL "g_unix_connection_receive_credentials" result+        result' <- (wrapObject Credentials) result+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )++-- method UnixConnection::receive_credentials_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_connection_receive_credentials_async" g_unix_connection_receive_credentials_async :: +    Ptr UnixConnection ->                   -- _obj : TInterface "Gio" "UnixConnection"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++unixConnectionReceiveCredentialsAsync ::+    (MonadIO m, UnixConnectionK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+unixConnectionReceiveCredentialsAsync _obj cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_unix_connection_receive_credentials_async _obj' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method UnixConnection::receive_credentials_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Credentials"+-- throws : True+-- Skip return : False++foreign import ccall "g_unix_connection_receive_credentials_finish" g_unix_connection_receive_credentials_finish :: +    Ptr UnixConnection ->                   -- _obj : TInterface "Gio" "UnixConnection"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Credentials)+++unixConnectionReceiveCredentialsFinish ::+    (MonadIO m, UnixConnectionK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m Credentials+unixConnectionReceiveCredentialsFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        result <- propagateGError $ g_unix_connection_receive_credentials_finish _obj' result_'+        checkUnexpectedReturnNULL "g_unix_connection_receive_credentials_finish" result+        result' <- (wrapObject Credentials) result+        touchManagedPtr _obj+        touchManagedPtr result_+        return result'+     ) (do+        return ()+     )++-- method UnixConnection::receive_fd+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : True+-- Skip return : False++foreign import ccall "g_unix_connection_receive_fd" g_unix_connection_receive_fd :: +    Ptr UnixConnection ->                   -- _obj : TInterface "Gio" "UnixConnection"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO Int32+++unixConnectionReceiveFd ::+    (MonadIO m, UnixConnectionK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m Int32+unixConnectionReceiveFd _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ g_unix_connection_receive_fd _obj' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return result+     ) (do+        return ()+     )++-- method UnixConnection::send_credentials+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_unix_connection_send_credentials" g_unix_connection_send_credentials :: +    Ptr UnixConnection ->                   -- _obj : TInterface "Gio" "UnixConnection"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++unixConnectionSendCredentials ::+    (MonadIO m, UnixConnectionK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    m ()+unixConnectionSendCredentials _obj cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_unix_connection_send_credentials _obj' maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++-- method UnixConnection::send_credentials_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gio" "AsyncReadyCallback", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_connection_send_credentials_async" g_unix_connection_send_credentials_async :: +    Ptr UnixConnection ->                   -- _obj : TInterface "Gio" "UnixConnection"+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr AsyncReadyCallbackC ->           -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++unixConnectionSendCredentialsAsync ::+    (MonadIO m, UnixConnectionK a, CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    Maybe (AsyncReadyCallback) ->           -- callback+    m ()+unixConnectionSendCredentialsAsync _obj cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- mkAsyncReadyCallback (asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    g_unix_connection_send_credentials_async _obj' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method UnixConnection::send_credentials_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "result", argType = TInterface "Gio" "AsyncResult", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_unix_connection_send_credentials_finish" g_unix_connection_send_credentials_finish :: +    Ptr UnixConnection ->                   -- _obj : TInterface "Gio" "UnixConnection"+    Ptr AsyncResult ->                      -- result : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++unixConnectionSendCredentialsFinish ::+    (MonadIO m, UnixConnectionK a, AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- result+    m ()+unixConnectionSendCredentialsFinish _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let result_' = unsafeManagedPtrCastPtr result_+    onException (do+        _ <- propagateGError $ g_unix_connection_send_credentials_finish _obj' result_'+        touchManagedPtr _obj+        touchManagedPtr result_+        return ()+     ) (do+        return ()+     )++-- method UnixConnection::send_fd+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fd", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixConnection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fd", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_unix_connection_send_fd" g_unix_connection_send_fd :: +    Ptr UnixConnection ->                   -- _obj : TInterface "Gio" "UnixConnection"+    Int32 ->                                -- fd : TBasicType TInt32+    Ptr Cancellable ->                      -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++unixConnectionSendFd ::+    (MonadIO m, UnixConnectionK a, CancellableK b) =>+    a ->                                    -- _obj+    Int32 ->                                -- fd+    Maybe (b) ->                            -- cancellable+    m ()+unixConnectionSendFd _obj fd cancellable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ g_unix_connection_send_fd _obj' fd maybeCancellable+        touchManagedPtr _obj+        whenJust cancellable touchManagedPtr+        return ()+     ) (do+        return ()+     )++
+ GI/Gio/Objects/UnixConnection.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Objects.UnixConnection where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype UnixConnection = UnixConnection (ForeignPtr UnixConnection)+instance GObject UnixConnection where+class GObject o => UnixConnectionK o+instance (GObject o, IsDescendantOf UnixConnection o) => UnixConnectionK o
+ GI/Gio/Objects/UnixCredentialsMessage.hs view
@@ -0,0 +1,202 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.UnixCredentialsMessage+    ( ++-- * Exported types+    UnixCredentialsMessage(..)              ,+    UnixCredentialsMessageK                 ,+    toUnixCredentialsMessage                ,+    noUnixCredentialsMessage                ,+++ -- * Methods+-- ** unixCredentialsMessageGetCredentials+    unixCredentialsMessageGetCredentials    ,+++-- ** unixCredentialsMessageIsSupported+    unixCredentialsMessageIsSupported       ,+++-- ** unixCredentialsMessageNew+    unixCredentialsMessageNew               ,+++-- ** unixCredentialsMessageNewWithCredentials+    unixCredentialsMessageNewWithCredentials,+++++ -- * Properties+-- ** Credentials+    UnixCredentialsMessageCredentialsPropertyInfo,+    constructUnixCredentialsMessageCredentials,+    getUnixCredentialsMessageCredentials    ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype UnixCredentialsMessage = UnixCredentialsMessage (ForeignPtr UnixCredentialsMessage)+foreign import ccall "g_unix_credentials_message_get_type"+    c_g_unix_credentials_message_get_type :: IO GType++type instance ParentTypes UnixCredentialsMessage = UnixCredentialsMessageParentTypes+type UnixCredentialsMessageParentTypes = '[SocketControlMessage, GObject.Object]++instance GObject UnixCredentialsMessage where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_unix_credentials_message_get_type+    ++class GObject o => UnixCredentialsMessageK o+instance (GObject o, IsDescendantOf UnixCredentialsMessage o) => UnixCredentialsMessageK o++toUnixCredentialsMessage :: UnixCredentialsMessageK o => o -> IO UnixCredentialsMessage+toUnixCredentialsMessage = unsafeCastTo UnixCredentialsMessage++noUnixCredentialsMessage :: Maybe UnixCredentialsMessage+noUnixCredentialsMessage = Nothing++-- VVV Prop "credentials"+   -- Type: TInterface "Gio" "Credentials"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getUnixCredentialsMessageCredentials :: (MonadIO m, UnixCredentialsMessageK o) => o -> m Credentials+getUnixCredentialsMessageCredentials obj = liftIO $ getObjectPropertyObject obj "credentials" Credentials++constructUnixCredentialsMessageCredentials :: (CredentialsK a) => a -> IO ([Char], GValue)+constructUnixCredentialsMessageCredentials val = constructObjectPropertyObject "credentials" val++data UnixCredentialsMessageCredentialsPropertyInfo+instance AttrInfo UnixCredentialsMessageCredentialsPropertyInfo where+    type AttrAllowedOps UnixCredentialsMessageCredentialsPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint UnixCredentialsMessageCredentialsPropertyInfo = CredentialsK+    type AttrBaseTypeConstraint UnixCredentialsMessageCredentialsPropertyInfo = UnixCredentialsMessageK+    type AttrGetType UnixCredentialsMessageCredentialsPropertyInfo = Credentials+    type AttrLabel UnixCredentialsMessageCredentialsPropertyInfo = "UnixCredentialsMessage::credentials"+    attrGet _ = getUnixCredentialsMessageCredentials+    attrSet _ = undefined+    attrConstruct _ = constructUnixCredentialsMessageCredentials++type instance AttributeList UnixCredentialsMessage = UnixCredentialsMessageAttributeList+type UnixCredentialsMessageAttributeList = ('[ '("credentials", UnixCredentialsMessageCredentialsPropertyInfo)] :: [(Symbol, *)])++type instance SignalList UnixCredentialsMessage = UnixCredentialsMessageSignalList+type UnixCredentialsMessageSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method UnixCredentialsMessage::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gio" "UnixCredentialsMessage"+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_credentials_message_new" g_unix_credentials_message_new :: +    IO (Ptr UnixCredentialsMessage)+++unixCredentialsMessageNew ::+    (MonadIO m) =>+    m UnixCredentialsMessage+unixCredentialsMessageNew  = liftIO $ do+    result <- g_unix_credentials_message_new+    checkUnexpectedReturnNULL "g_unix_credentials_message_new" result+    result' <- (wrapObject UnixCredentialsMessage) result+    return result'++-- method UnixCredentialsMessage::new_with_credentials+-- method type : Constructor+-- Args : [Arg {argName = "credentials", argType = TInterface "Gio" "Credentials", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "credentials", argType = TInterface "Gio" "Credentials", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "UnixCredentialsMessage"+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_credentials_message_new_with_credentials" g_unix_credentials_message_new_with_credentials :: +    Ptr Credentials ->                      -- credentials : TInterface "Gio" "Credentials"+    IO (Ptr UnixCredentialsMessage)+++unixCredentialsMessageNewWithCredentials ::+    (MonadIO m, CredentialsK a) =>+    a ->                                    -- credentials+    m UnixCredentialsMessage+unixCredentialsMessageNewWithCredentials credentials = liftIO $ do+    let credentials' = unsafeManagedPtrCastPtr credentials+    result <- g_unix_credentials_message_new_with_credentials credentials'+    checkUnexpectedReturnNULL "g_unix_credentials_message_new_with_credentials" result+    result' <- (wrapObject UnixCredentialsMessage) result+    touchManagedPtr credentials+    return result'++-- method UnixCredentialsMessage::get_credentials+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixCredentialsMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixCredentialsMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Credentials"+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_credentials_message_get_credentials" g_unix_credentials_message_get_credentials :: +    Ptr UnixCredentialsMessage ->           -- _obj : TInterface "Gio" "UnixCredentialsMessage"+    IO (Ptr Credentials)+++unixCredentialsMessageGetCredentials ::+    (MonadIO m, UnixCredentialsMessageK a) =>+    a ->                                    -- _obj+    m Credentials+unixCredentialsMessageGetCredentials _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_unix_credentials_message_get_credentials _obj'+    checkUnexpectedReturnNULL "g_unix_credentials_message_get_credentials" result+    result' <- (newObject Credentials) result+    touchManagedPtr _obj+    return result'++-- method UnixCredentialsMessage::is_supported+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_credentials_message_is_supported" g_unix_credentials_message_is_supported :: +    IO CInt+++unixCredentialsMessageIsSupported ::+    (MonadIO m) =>+    m Bool+unixCredentialsMessageIsSupported  = liftIO $ do+    result <- g_unix_credentials_message_is_supported+    let result' = (/= 0) result+    return result'++
+ GI/Gio/Objects/UnixCredentialsMessage.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gio.Objects.UnixCredentialsMessage where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype UnixCredentialsMessage = UnixCredentialsMessage (ForeignPtr UnixCredentialsMessage)+instance GObject UnixCredentialsMessage where+class GObject o => UnixCredentialsMessageK o+instance (GObject o, IsDescendantOf UnixCredentialsMessage o) => UnixCredentialsMessageK o+data UnixCredentialsMessageCredentialsPropertyInfo
+ GI/Gio/Objects/UnixFDList.hs view
@@ -0,0 +1,286 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.UnixFDList+    ( ++-- * Exported types+    UnixFDList(..)                          ,+    UnixFDListK                             ,+    toUnixFDList                            ,+    noUnixFDList                            ,+++ -- * Methods+-- ** unixFDListAppend+    unixFDListAppend                        ,+++-- ** unixFDListGet+    unixFDListGet                           ,+++-- ** unixFDListGetLength+    unixFDListGetLength                     ,+++-- ** unixFDListNew+    unixFDListNew                           ,+++-- ** unixFDListNewFromArray+    unixFDListNewFromArray                  ,+++-- ** unixFDListPeekFds+    unixFDListPeekFds                       ,+++-- ** unixFDListStealFds+    unixFDListStealFds                      ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype UnixFDList = UnixFDList (ForeignPtr UnixFDList)+foreign import ccall "g_unix_fd_list_get_type"+    c_g_unix_fd_list_get_type :: IO GType++type instance ParentTypes UnixFDList = UnixFDListParentTypes+type UnixFDListParentTypes = '[GObject.Object]++instance GObject UnixFDList where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_unix_fd_list_get_type+    ++class GObject o => UnixFDListK o+instance (GObject o, IsDescendantOf UnixFDList o) => UnixFDListK o++toUnixFDList :: UnixFDListK o => o -> IO UnixFDList+toUnixFDList = unsafeCastTo UnixFDList++noUnixFDList :: Maybe UnixFDList+noUnixFDList = Nothing++type instance AttributeList UnixFDList = UnixFDListAttributeList+type UnixFDListAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList UnixFDList = UnixFDListSignalList+type UnixFDListSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method UnixFDList::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gio" "UnixFDList"+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_fd_list_new" g_unix_fd_list_new :: +    IO (Ptr UnixFDList)+++unixFDListNew ::+    (MonadIO m) =>+    m UnixFDList+unixFDListNew  = liftIO $ do+    result <- g_unix_fd_list_new+    checkUnexpectedReturnNULL "g_unix_fd_list_new" result+    result' <- (wrapObject UnixFDList) result+    return result'++-- method UnixFDList::new_from_array+-- method type : Constructor+-- Args : [Arg {argName = "fds", argType = TCArray False (-1) 1 (TBasicType TInt32), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_fds", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "n_fds", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "fds", argType = TCArray False (-1) 1 (TBasicType TInt32), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "UnixFDList"+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_fd_list_new_from_array" g_unix_fd_list_new_from_array :: +    Ptr Int32 ->                            -- fds : TCArray False (-1) 1 (TBasicType TInt32)+    Int32 ->                                -- n_fds : TBasicType TInt32+    IO (Ptr UnixFDList)+++unixFDListNewFromArray ::+    (MonadIO m) =>+    [Int32] ->                              -- fds+    m UnixFDList+unixFDListNewFromArray fds = liftIO $ do+    let n_fds = fromIntegral $ length fds+    fds' <- packStorableArray fds+    result <- g_unix_fd_list_new_from_array fds' n_fds+    checkUnexpectedReturnNULL "g_unix_fd_list_new_from_array" result+    result' <- (wrapObject UnixFDList) result+    freeMem fds'+    return result'++-- method UnixFDList::append+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixFDList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fd", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixFDList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fd", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : True+-- Skip return : False++foreign import ccall "g_unix_fd_list_append" g_unix_fd_list_append :: +    Ptr UnixFDList ->                       -- _obj : TInterface "Gio" "UnixFDList"+    Int32 ->                                -- fd : TBasicType TInt32+    Ptr (Ptr GError) ->                     -- error+    IO Int32+++unixFDListAppend ::+    (MonadIO m, UnixFDListK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- fd+    m Int32+unixFDListAppend _obj fd = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    onException (do+        result <- propagateGError $ g_unix_fd_list_append _obj' fd+        touchManagedPtr _obj+        return result+     ) (do+        return ()+     )++-- method UnixFDList::get+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixFDList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "index_", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixFDList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "index_", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : True+-- Skip return : False++foreign import ccall "g_unix_fd_list_get" g_unix_fd_list_get :: +    Ptr UnixFDList ->                       -- _obj : TInterface "Gio" "UnixFDList"+    Int32 ->                                -- index_ : TBasicType TInt32+    Ptr (Ptr GError) ->                     -- error+    IO Int32+++unixFDListGet ::+    (MonadIO m, UnixFDListK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- index_+    m Int32+unixFDListGet _obj index_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    onException (do+        result <- propagateGError $ g_unix_fd_list_get _obj' index_+        touchManagedPtr _obj+        return result+     ) (do+        return ()+     )++-- method UnixFDList::get_length+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixFDList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixFDList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_fd_list_get_length" g_unix_fd_list_get_length :: +    Ptr UnixFDList ->                       -- _obj : TInterface "Gio" "UnixFDList"+    IO Int32+++unixFDListGetLength ::+    (MonadIO m, UnixFDListK a) =>+    a ->                                    -- _obj+    m Int32+unixFDListGetLength _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_unix_fd_list_get_length _obj'+    touchManagedPtr _obj+    return result++-- method UnixFDList::peek_fds+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixFDList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "length", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : [Arg {argName = "length", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixFDList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray False (-1) 1 (TBasicType TInt32)+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_fd_list_peek_fds" g_unix_fd_list_peek_fds :: +    Ptr UnixFDList ->                       -- _obj : TInterface "Gio" "UnixFDList"+    Ptr Int32 ->                            -- length : TBasicType TInt32+    IO (Ptr Int32)+++unixFDListPeekFds ::+    (MonadIO m, UnixFDListK a) =>+    a ->                                    -- _obj+    m [Int32]+unixFDListPeekFds _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    length_ <- allocMem :: IO (Ptr Int32)+    result <- g_unix_fd_list_peek_fds _obj' length_+    length_' <- peek length_+    checkUnexpectedReturnNULL "g_unix_fd_list_peek_fds" result+    result' <- (unpackStorableArrayWithLength length_') result+    touchManagedPtr _obj+    freeMem length_+    return result'++-- method UnixFDList::steal_fds+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixFDList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "length", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : [Arg {argName = "length", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixFDList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray False (-1) 1 (TBasicType TInt32)+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_fd_list_steal_fds" g_unix_fd_list_steal_fds :: +    Ptr UnixFDList ->                       -- _obj : TInterface "Gio" "UnixFDList"+    Ptr Int32 ->                            -- length : TBasicType TInt32+    IO (Ptr Int32)+++unixFDListStealFds ::+    (MonadIO m, UnixFDListK a) =>+    a ->                                    -- _obj+    m [Int32]+unixFDListStealFds _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    length_ <- allocMem :: IO (Ptr Int32)+    result <- g_unix_fd_list_steal_fds _obj' length_+    length_' <- peek length_+    checkUnexpectedReturnNULL "g_unix_fd_list_steal_fds" result+    result' <- (unpackStorableArrayWithLength length_') result+    freeMem result+    touchManagedPtr _obj+    freeMem length_+    return result'++
+ GI/Gio/Objects/UnixFDList.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Objects.UnixFDList where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype UnixFDList = UnixFDList (ForeignPtr UnixFDList)+instance GObject UnixFDList where+class GObject o => UnixFDListK o+instance (GObject o, IsDescendantOf UnixFDList o) => UnixFDListK o
+ GI/Gio/Objects/UnixFDMessage.hs view
@@ -0,0 +1,247 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.UnixFDMessage+    ( ++-- * Exported types+    UnixFDMessage(..)                       ,+    UnixFDMessageK                          ,+    toUnixFDMessage                         ,+    noUnixFDMessage                         ,+++ -- * Methods+-- ** unixFDMessageAppendFd+    unixFDMessageAppendFd                   ,+++-- ** unixFDMessageGetFdList+    unixFDMessageGetFdList                  ,+++-- ** unixFDMessageNew+    unixFDMessageNew                        ,+++-- ** unixFDMessageNewWithFdList+    unixFDMessageNewWithFdList              ,+++-- ** unixFDMessageStealFds+    unixFDMessageStealFds                   ,+++++ -- * Properties+-- ** FdList+    UnixFDMessageFdListPropertyInfo         ,+    constructUnixFDMessageFdList            ,+    getUnixFDMessageFdList                  ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype UnixFDMessage = UnixFDMessage (ForeignPtr UnixFDMessage)+foreign import ccall "g_unix_fd_message_get_type"+    c_g_unix_fd_message_get_type :: IO GType++type instance ParentTypes UnixFDMessage = UnixFDMessageParentTypes+type UnixFDMessageParentTypes = '[SocketControlMessage, GObject.Object]++instance GObject UnixFDMessage where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_unix_fd_message_get_type+    ++class GObject o => UnixFDMessageK o+instance (GObject o, IsDescendantOf UnixFDMessage o) => UnixFDMessageK o++toUnixFDMessage :: UnixFDMessageK o => o -> IO UnixFDMessage+toUnixFDMessage = unsafeCastTo UnixFDMessage++noUnixFDMessage :: Maybe UnixFDMessage+noUnixFDMessage = Nothing++-- VVV Prop "fd-list"+   -- Type: TInterface "Gio" "UnixFDList"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getUnixFDMessageFdList :: (MonadIO m, UnixFDMessageK o) => o -> m UnixFDList+getUnixFDMessageFdList obj = liftIO $ getObjectPropertyObject obj "fd-list" UnixFDList++constructUnixFDMessageFdList :: (UnixFDListK a) => a -> IO ([Char], GValue)+constructUnixFDMessageFdList val = constructObjectPropertyObject "fd-list" val++data UnixFDMessageFdListPropertyInfo+instance AttrInfo UnixFDMessageFdListPropertyInfo where+    type AttrAllowedOps UnixFDMessageFdListPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint UnixFDMessageFdListPropertyInfo = UnixFDListK+    type AttrBaseTypeConstraint UnixFDMessageFdListPropertyInfo = UnixFDMessageK+    type AttrGetType UnixFDMessageFdListPropertyInfo = UnixFDList+    type AttrLabel UnixFDMessageFdListPropertyInfo = "UnixFDMessage::fd-list"+    attrGet _ = getUnixFDMessageFdList+    attrSet _ = undefined+    attrConstruct _ = constructUnixFDMessageFdList++type instance AttributeList UnixFDMessage = UnixFDMessageAttributeList+type UnixFDMessageAttributeList = ('[ '("fd-list", UnixFDMessageFdListPropertyInfo)] :: [(Symbol, *)])++type instance SignalList UnixFDMessage = UnixFDMessageSignalList+type UnixFDMessageSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method UnixFDMessage::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gio" "UnixFDMessage"+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_fd_message_new" g_unix_fd_message_new :: +    IO (Ptr UnixFDMessage)+++unixFDMessageNew ::+    (MonadIO m) =>+    m UnixFDMessage+unixFDMessageNew  = liftIO $ do+    result <- g_unix_fd_message_new+    checkUnexpectedReturnNULL "g_unix_fd_message_new" result+    result' <- (wrapObject UnixFDMessage) result+    return result'++-- method UnixFDMessage::new_with_fd_list+-- method type : Constructor+-- Args : [Arg {argName = "fd_list", argType = TInterface "Gio" "UnixFDList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "fd_list", argType = TInterface "Gio" "UnixFDList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "UnixFDMessage"+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_fd_message_new_with_fd_list" g_unix_fd_message_new_with_fd_list :: +    Ptr UnixFDList ->                       -- fd_list : TInterface "Gio" "UnixFDList"+    IO (Ptr UnixFDMessage)+++unixFDMessageNewWithFdList ::+    (MonadIO m, UnixFDListK a) =>+    a ->                                    -- fd_list+    m UnixFDMessage+unixFDMessageNewWithFdList fd_list = liftIO $ do+    let fd_list' = unsafeManagedPtrCastPtr fd_list+    result <- g_unix_fd_message_new_with_fd_list fd_list'+    checkUnexpectedReturnNULL "g_unix_fd_message_new_with_fd_list" result+    result' <- (wrapObject UnixFDMessage) result+    touchManagedPtr fd_list+    return result'++-- method UnixFDMessage::append_fd+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixFDMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fd", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixFDMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fd", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_unix_fd_message_append_fd" g_unix_fd_message_append_fd :: +    Ptr UnixFDMessage ->                    -- _obj : TInterface "Gio" "UnixFDMessage"+    Int32 ->                                -- fd : TBasicType TInt32+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++unixFDMessageAppendFd ::+    (MonadIO m, UnixFDMessageK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- fd+    m ()+unixFDMessageAppendFd _obj fd = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    onException (do+        _ <- propagateGError $ g_unix_fd_message_append_fd _obj' fd+        touchManagedPtr _obj+        return ()+     ) (do+        return ()+     )++-- method UnixFDMessage::get_fd_list+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixFDMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixFDMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "UnixFDList"+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_fd_message_get_fd_list" g_unix_fd_message_get_fd_list :: +    Ptr UnixFDMessage ->                    -- _obj : TInterface "Gio" "UnixFDMessage"+    IO (Ptr UnixFDList)+++unixFDMessageGetFdList ::+    (MonadIO m, UnixFDMessageK a) =>+    a ->                                    -- _obj+    m UnixFDList+unixFDMessageGetFdList _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_unix_fd_message_get_fd_list _obj'+    checkUnexpectedReturnNULL "g_unix_fd_message_get_fd_list" result+    result' <- (newObject UnixFDList) result+    touchManagedPtr _obj+    return result'++-- method UnixFDMessage::steal_fds+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixFDMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "length", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : [Arg {argName = "length", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixFDMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray False (-1) 1 (TBasicType TInt32)+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_fd_message_steal_fds" g_unix_fd_message_steal_fds :: +    Ptr UnixFDMessage ->                    -- _obj : TInterface "Gio" "UnixFDMessage"+    Ptr Int32 ->                            -- length : TBasicType TInt32+    IO (Ptr Int32)+++unixFDMessageStealFds ::+    (MonadIO m, UnixFDMessageK a) =>+    a ->                                    -- _obj+    m [Int32]+unixFDMessageStealFds _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    length_ <- allocMem :: IO (Ptr Int32)+    result <- g_unix_fd_message_steal_fds _obj' length_+    length_' <- peek length_+    checkUnexpectedReturnNULL "g_unix_fd_message_steal_fds" result+    result' <- (unpackStorableArrayWithLength length_') result+    freeMem result+    touchManagedPtr _obj+    freeMem length_+    return result'++
+ GI/Gio/Objects/UnixFDMessage.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gio.Objects.UnixFDMessage where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype UnixFDMessage = UnixFDMessage (ForeignPtr UnixFDMessage)+instance GObject UnixFDMessage where+class GObject o => UnixFDMessageK o+instance (GObject o, IsDescendantOf UnixFDMessage o) => UnixFDMessageK o+data UnixFDMessageFdListPropertyInfo
+ GI/Gio/Objects/UnixInputStream.hs view
@@ -0,0 +1,241 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.UnixInputStream+    ( ++-- * Exported types+    UnixInputStream(..)                     ,+    UnixInputStreamK                        ,+    toUnixInputStream                       ,+    noUnixInputStream                       ,+++ -- * Methods+-- ** unixInputStreamGetCloseFd+    unixInputStreamGetCloseFd               ,+++-- ** unixInputStreamGetFd+    unixInputStreamGetFd                    ,+++-- ** unixInputStreamNew+    unixInputStreamNew                      ,+++-- ** unixInputStreamSetCloseFd+    unixInputStreamSetCloseFd               ,+++++ -- * Properties+-- ** CloseFd+    UnixInputStreamCloseFdPropertyInfo      ,+    constructUnixInputStreamCloseFd         ,+    getUnixInputStreamCloseFd               ,+    setUnixInputStreamCloseFd               ,+++-- ** Fd+    UnixInputStreamFdPropertyInfo           ,+    constructUnixInputStreamFd              ,+    getUnixInputStreamFd                    ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype UnixInputStream = UnixInputStream (ForeignPtr UnixInputStream)+foreign import ccall "g_unix_input_stream_get_type"+    c_g_unix_input_stream_get_type :: IO GType++type instance ParentTypes UnixInputStream = UnixInputStreamParentTypes+type UnixInputStreamParentTypes = '[InputStream, GObject.Object, FileDescriptorBased, PollableInputStream]++instance GObject UnixInputStream where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_unix_input_stream_get_type+    ++class GObject o => UnixInputStreamK o+instance (GObject o, IsDescendantOf UnixInputStream o) => UnixInputStreamK o++toUnixInputStream :: UnixInputStreamK o => o -> IO UnixInputStream+toUnixInputStream = unsafeCastTo UnixInputStream++noUnixInputStream :: Maybe UnixInputStream+noUnixInputStream = Nothing++-- VVV Prop "close-fd"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getUnixInputStreamCloseFd :: (MonadIO m, UnixInputStreamK o) => o -> m Bool+getUnixInputStreamCloseFd obj = liftIO $ getObjectPropertyBool obj "close-fd"++setUnixInputStreamCloseFd :: (MonadIO m, UnixInputStreamK o) => o -> Bool -> m ()+setUnixInputStreamCloseFd obj val = liftIO $ setObjectPropertyBool obj "close-fd" val++constructUnixInputStreamCloseFd :: Bool -> IO ([Char], GValue)+constructUnixInputStreamCloseFd val = constructObjectPropertyBool "close-fd" val++data UnixInputStreamCloseFdPropertyInfo+instance AttrInfo UnixInputStreamCloseFdPropertyInfo where+    type AttrAllowedOps UnixInputStreamCloseFdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint UnixInputStreamCloseFdPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint UnixInputStreamCloseFdPropertyInfo = UnixInputStreamK+    type AttrGetType UnixInputStreamCloseFdPropertyInfo = Bool+    type AttrLabel UnixInputStreamCloseFdPropertyInfo = "UnixInputStream::close-fd"+    attrGet _ = getUnixInputStreamCloseFd+    attrSet _ = setUnixInputStreamCloseFd+    attrConstruct _ = constructUnixInputStreamCloseFd++-- VVV Prop "fd"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getUnixInputStreamFd :: (MonadIO m, UnixInputStreamK o) => o -> m Int32+getUnixInputStreamFd obj = liftIO $ getObjectPropertyCInt obj "fd"++constructUnixInputStreamFd :: Int32 -> IO ([Char], GValue)+constructUnixInputStreamFd val = constructObjectPropertyCInt "fd" val++data UnixInputStreamFdPropertyInfo+instance AttrInfo UnixInputStreamFdPropertyInfo where+    type AttrAllowedOps UnixInputStreamFdPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint UnixInputStreamFdPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint UnixInputStreamFdPropertyInfo = UnixInputStreamK+    type AttrGetType UnixInputStreamFdPropertyInfo = Int32+    type AttrLabel UnixInputStreamFdPropertyInfo = "UnixInputStream::fd"+    attrGet _ = getUnixInputStreamFd+    attrSet _ = undefined+    attrConstruct _ = constructUnixInputStreamFd++type instance AttributeList UnixInputStream = UnixInputStreamAttributeList+type UnixInputStreamAttributeList = ('[ '("close-fd", UnixInputStreamCloseFdPropertyInfo), '("fd", UnixInputStreamFdPropertyInfo)] :: [(Symbol, *)])++type instance SignalList UnixInputStream = UnixInputStreamSignalList+type UnixInputStreamSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method UnixInputStream::new+-- method type : Constructor+-- Args : [Arg {argName = "fd", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "close_fd", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "fd", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "close_fd", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "UnixInputStream"+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_input_stream_new" g_unix_input_stream_new :: +    Int32 ->                                -- fd : TBasicType TInt32+    CInt ->                                 -- close_fd : TBasicType TBoolean+    IO (Ptr UnixInputStream)+++unixInputStreamNew ::+    (MonadIO m) =>+    Int32 ->                                -- fd+    Bool ->                                 -- close_fd+    m UnixInputStream+unixInputStreamNew fd close_fd = liftIO $ do+    let close_fd' = (fromIntegral . fromEnum) close_fd+    result <- g_unix_input_stream_new fd close_fd'+    checkUnexpectedReturnNULL "g_unix_input_stream_new" result+    result' <- (wrapObject UnixInputStream) result+    return result'++-- method UnixInputStream::get_close_fd+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_input_stream_get_close_fd" g_unix_input_stream_get_close_fd :: +    Ptr UnixInputStream ->                  -- _obj : TInterface "Gio" "UnixInputStream"+    IO CInt+++unixInputStreamGetCloseFd ::+    (MonadIO m, UnixInputStreamK a) =>+    a ->                                    -- _obj+    m Bool+unixInputStreamGetCloseFd _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_unix_input_stream_get_close_fd _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method UnixInputStream::get_fd+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_input_stream_get_fd" g_unix_input_stream_get_fd :: +    Ptr UnixInputStream ->                  -- _obj : TInterface "Gio" "UnixInputStream"+    IO Int32+++unixInputStreamGetFd ::+    (MonadIO m, UnixInputStreamK a) =>+    a ->                                    -- _obj+    m Int32+unixInputStreamGetFd _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_unix_input_stream_get_fd _obj'+    touchManagedPtr _obj+    return result++-- method UnixInputStream::set_close_fd+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "close_fd", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixInputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "close_fd", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_input_stream_set_close_fd" g_unix_input_stream_set_close_fd :: +    Ptr UnixInputStream ->                  -- _obj : TInterface "Gio" "UnixInputStream"+    CInt ->                                 -- close_fd : TBasicType TBoolean+    IO ()+++unixInputStreamSetCloseFd ::+    (MonadIO m, UnixInputStreamK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- close_fd+    m ()+unixInputStreamSetCloseFd _obj close_fd = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let close_fd' = (fromIntegral . fromEnum) close_fd+    g_unix_input_stream_set_close_fd _obj' close_fd'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Objects/UnixInputStream.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gio.Objects.UnixInputStream where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype UnixInputStream = UnixInputStream (ForeignPtr UnixInputStream)+instance GObject UnixInputStream where+class GObject o => UnixInputStreamK o+instance (GObject o, IsDescendantOf UnixInputStream o) => UnixInputStreamK o+data UnixInputStreamCloseFdPropertyInfo+data UnixInputStreamFdPropertyInfo
+ GI/Gio/Objects/UnixMountMonitor.hs view
@@ -0,0 +1,256 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.UnixMountMonitor+    ( ++-- * Exported types+    UnixMountMonitor(..)                    ,+    UnixMountMonitorK                       ,+    toUnixMountMonitor                      ,+    noUnixMountMonitor                      ,+++ -- * Methods+-- ** unixMountMonitorGet+    unixMountMonitorGet                     ,+++-- ** unixMountMonitorNew+    unixMountMonitorNew                     ,+++-- ** unixMountMonitorSetRateLimit+    unixMountMonitorSetRateLimit            ,+++++ -- * Signals+-- ** MountpointsChanged+    UnixMountMonitorMountpointsChangedCallback,+    UnixMountMonitorMountpointsChangedCallbackC,+    UnixMountMonitorMountpointsChangedSignalInfo,+    afterUnixMountMonitorMountpointsChanged ,+    mkUnixMountMonitorMountpointsChangedCallback,+    noUnixMountMonitorMountpointsChangedCallback,+    onUnixMountMonitorMountpointsChanged    ,+    unixMountMonitorMountpointsChangedCallbackWrapper,+    unixMountMonitorMountpointsChangedClosure,+++-- ** MountsChanged+    UnixMountMonitorMountsChangedCallback   ,+    UnixMountMonitorMountsChangedCallbackC  ,+    UnixMountMonitorMountsChangedSignalInfo ,+    afterUnixMountMonitorMountsChanged      ,+    mkUnixMountMonitorMountsChangedCallback ,+    noUnixMountMonitorMountsChangedCallback ,+    onUnixMountMonitorMountsChanged         ,+    unixMountMonitorMountsChangedCallbackWrapper,+    unixMountMonitorMountsChangedClosure    ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype UnixMountMonitor = UnixMountMonitor (ForeignPtr UnixMountMonitor)+foreign import ccall "g_unix_mount_monitor_get_type"+    c_g_unix_mount_monitor_get_type :: IO GType++type instance ParentTypes UnixMountMonitor = UnixMountMonitorParentTypes+type UnixMountMonitorParentTypes = '[GObject.Object]++instance GObject UnixMountMonitor where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_unix_mount_monitor_get_type+    ++class GObject o => UnixMountMonitorK o+instance (GObject o, IsDescendantOf UnixMountMonitor o) => UnixMountMonitorK o++toUnixMountMonitor :: UnixMountMonitorK o => o -> IO UnixMountMonitor+toUnixMountMonitor = unsafeCastTo UnixMountMonitor++noUnixMountMonitor :: Maybe UnixMountMonitor+noUnixMountMonitor = Nothing++-- signal UnixMountMonitor::mountpoints-changed+type UnixMountMonitorMountpointsChangedCallback =+    IO ()++noUnixMountMonitorMountpointsChangedCallback :: Maybe UnixMountMonitorMountpointsChangedCallback+noUnixMountMonitorMountpointsChangedCallback = Nothing++type UnixMountMonitorMountpointsChangedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkUnixMountMonitorMountpointsChangedCallback :: UnixMountMonitorMountpointsChangedCallbackC -> IO (FunPtr UnixMountMonitorMountpointsChangedCallbackC)++unixMountMonitorMountpointsChangedClosure :: UnixMountMonitorMountpointsChangedCallback -> IO Closure+unixMountMonitorMountpointsChangedClosure cb = newCClosure =<< mkUnixMountMonitorMountpointsChangedCallback wrapped+    where wrapped = unixMountMonitorMountpointsChangedCallbackWrapper cb++unixMountMonitorMountpointsChangedCallbackWrapper ::+    UnixMountMonitorMountpointsChangedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+unixMountMonitorMountpointsChangedCallbackWrapper _cb _ _ = do+    _cb ++onUnixMountMonitorMountpointsChanged :: (GObject a, MonadIO m) => a -> UnixMountMonitorMountpointsChangedCallback -> m SignalHandlerId+onUnixMountMonitorMountpointsChanged obj cb = liftIO $ connectUnixMountMonitorMountpointsChanged obj cb SignalConnectBefore+afterUnixMountMonitorMountpointsChanged :: (GObject a, MonadIO m) => a -> UnixMountMonitorMountpointsChangedCallback -> m SignalHandlerId+afterUnixMountMonitorMountpointsChanged obj cb = connectUnixMountMonitorMountpointsChanged obj cb SignalConnectAfter++connectUnixMountMonitorMountpointsChanged :: (GObject a, MonadIO m) =>+                                             a -> UnixMountMonitorMountpointsChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectUnixMountMonitorMountpointsChanged obj cb after = liftIO $ do+    cb' <- mkUnixMountMonitorMountpointsChangedCallback (unixMountMonitorMountpointsChangedCallbackWrapper cb)+    connectSignalFunPtr obj "mountpoints-changed" cb' after++-- signal UnixMountMonitor::mounts-changed+type UnixMountMonitorMountsChangedCallback =+    IO ()++noUnixMountMonitorMountsChangedCallback :: Maybe UnixMountMonitorMountsChangedCallback+noUnixMountMonitorMountsChangedCallback = Nothing++type UnixMountMonitorMountsChangedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkUnixMountMonitorMountsChangedCallback :: UnixMountMonitorMountsChangedCallbackC -> IO (FunPtr UnixMountMonitorMountsChangedCallbackC)++unixMountMonitorMountsChangedClosure :: UnixMountMonitorMountsChangedCallback -> IO Closure+unixMountMonitorMountsChangedClosure cb = newCClosure =<< mkUnixMountMonitorMountsChangedCallback wrapped+    where wrapped = unixMountMonitorMountsChangedCallbackWrapper cb++unixMountMonitorMountsChangedCallbackWrapper ::+    UnixMountMonitorMountsChangedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+unixMountMonitorMountsChangedCallbackWrapper _cb _ _ = do+    _cb ++onUnixMountMonitorMountsChanged :: (GObject a, MonadIO m) => a -> UnixMountMonitorMountsChangedCallback -> m SignalHandlerId+onUnixMountMonitorMountsChanged obj cb = liftIO $ connectUnixMountMonitorMountsChanged obj cb SignalConnectBefore+afterUnixMountMonitorMountsChanged :: (GObject a, MonadIO m) => a -> UnixMountMonitorMountsChangedCallback -> m SignalHandlerId+afterUnixMountMonitorMountsChanged obj cb = connectUnixMountMonitorMountsChanged obj cb SignalConnectAfter++connectUnixMountMonitorMountsChanged :: (GObject a, MonadIO m) =>+                                        a -> UnixMountMonitorMountsChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectUnixMountMonitorMountsChanged obj cb after = liftIO $ do+    cb' <- mkUnixMountMonitorMountsChangedCallback (unixMountMonitorMountsChangedCallbackWrapper cb)+    connectSignalFunPtr obj "mounts-changed" cb' after++type instance AttributeList UnixMountMonitor = UnixMountMonitorAttributeList+type UnixMountMonitorAttributeList = ('[ ] :: [(Symbol, *)])++data UnixMountMonitorMountpointsChangedSignalInfo+instance SignalInfo UnixMountMonitorMountpointsChangedSignalInfo where+    type HaskellCallbackType UnixMountMonitorMountpointsChangedSignalInfo = UnixMountMonitorMountpointsChangedCallback+    connectSignal _ = connectUnixMountMonitorMountpointsChanged++data UnixMountMonitorMountsChangedSignalInfo+instance SignalInfo UnixMountMonitorMountsChangedSignalInfo where+    type HaskellCallbackType UnixMountMonitorMountsChangedSignalInfo = UnixMountMonitorMountsChangedCallback+    connectSignal _ = connectUnixMountMonitorMountsChanged++type instance SignalList UnixMountMonitor = UnixMountMonitorSignalList+type UnixMountMonitorSignalList = ('[ '("mountpoints-changed", UnixMountMonitorMountpointsChangedSignalInfo), '("mounts-changed", UnixMountMonitorMountsChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method UnixMountMonitor::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gio" "UnixMountMonitor"+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_mount_monitor_new" g_unix_mount_monitor_new :: +    IO (Ptr UnixMountMonitor)++{-# DEPRECATED unixMountMonitorNew ["(Since version 2.44)","Use g_unix_mount_monitor_get() instead."]#-}+unixMountMonitorNew ::+    (MonadIO m) =>+    m UnixMountMonitor+unixMountMonitorNew  = liftIO $ do+    result <- g_unix_mount_monitor_new+    checkUnexpectedReturnNULL "g_unix_mount_monitor_new" result+    result' <- (wrapObject UnixMountMonitor) result+    return result'++-- method UnixMountMonitor::set_rate_limit+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixMountMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "limit_msec", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixMountMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "limit_msec", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_mount_monitor_set_rate_limit" g_unix_mount_monitor_set_rate_limit :: +    Ptr UnixMountMonitor ->                 -- _obj : TInterface "Gio" "UnixMountMonitor"+    Int32 ->                                -- limit_msec : TBasicType TInt32+    IO ()++{-# DEPRECATED unixMountMonitorSetRateLimit ["(Since version 2.44)","This function does nothing.  Don't call it."]#-}+unixMountMonitorSetRateLimit ::+    (MonadIO m, UnixMountMonitorK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- limit_msec+    m ()+unixMountMonitorSetRateLimit _obj limit_msec = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    g_unix_mount_monitor_set_rate_limit _obj' limit_msec+    touchManagedPtr _obj+    return ()++-- method UnixMountMonitor::get+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gio" "UnixMountMonitor"+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_mount_monitor_get" g_unix_mount_monitor_get :: +    IO (Ptr UnixMountMonitor)+++unixMountMonitorGet ::+    (MonadIO m) =>+    m UnixMountMonitor+unixMountMonitorGet  = liftIO $ do+    result <- g_unix_mount_monitor_get+    checkUnexpectedReturnNULL "g_unix_mount_monitor_get" result+    result' <- (wrapObject UnixMountMonitor) result+    return result'++
+ GI/Gio/Objects/UnixMountMonitor.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gio.Objects.UnixMountMonitor where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype UnixMountMonitor = UnixMountMonitor (ForeignPtr UnixMountMonitor)+instance GObject UnixMountMonitor where+class GObject o => UnixMountMonitorK o+instance (GObject o, IsDescendantOf UnixMountMonitor o) => UnixMountMonitorK o+data UnixMountMonitorMountpointsChangedSignalInfo+data UnixMountMonitorMountsChangedSignalInfo
+ GI/Gio/Objects/UnixOutputStream.hs view
@@ -0,0 +1,241 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.UnixOutputStream+    ( ++-- * Exported types+    UnixOutputStream(..)                    ,+    UnixOutputStreamK                       ,+    toUnixOutputStream                      ,+    noUnixOutputStream                      ,+++ -- * Methods+-- ** unixOutputStreamGetCloseFd+    unixOutputStreamGetCloseFd              ,+++-- ** unixOutputStreamGetFd+    unixOutputStreamGetFd                   ,+++-- ** unixOutputStreamNew+    unixOutputStreamNew                     ,+++-- ** unixOutputStreamSetCloseFd+    unixOutputStreamSetCloseFd              ,+++++ -- * Properties+-- ** CloseFd+    UnixOutputStreamCloseFdPropertyInfo     ,+    constructUnixOutputStreamCloseFd        ,+    getUnixOutputStreamCloseFd              ,+    setUnixOutputStreamCloseFd              ,+++-- ** Fd+    UnixOutputStreamFdPropertyInfo          ,+    constructUnixOutputStreamFd             ,+    getUnixOutputStreamFd                   ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype UnixOutputStream = UnixOutputStream (ForeignPtr UnixOutputStream)+foreign import ccall "g_unix_output_stream_get_type"+    c_g_unix_output_stream_get_type :: IO GType++type instance ParentTypes UnixOutputStream = UnixOutputStreamParentTypes+type UnixOutputStreamParentTypes = '[OutputStream, GObject.Object, FileDescriptorBased, PollableOutputStream]++instance GObject UnixOutputStream where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_unix_output_stream_get_type+    ++class GObject o => UnixOutputStreamK o+instance (GObject o, IsDescendantOf UnixOutputStream o) => UnixOutputStreamK o++toUnixOutputStream :: UnixOutputStreamK o => o -> IO UnixOutputStream+toUnixOutputStream = unsafeCastTo UnixOutputStream++noUnixOutputStream :: Maybe UnixOutputStream+noUnixOutputStream = Nothing++-- VVV Prop "close-fd"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getUnixOutputStreamCloseFd :: (MonadIO m, UnixOutputStreamK o) => o -> m Bool+getUnixOutputStreamCloseFd obj = liftIO $ getObjectPropertyBool obj "close-fd"++setUnixOutputStreamCloseFd :: (MonadIO m, UnixOutputStreamK o) => o -> Bool -> m ()+setUnixOutputStreamCloseFd obj val = liftIO $ setObjectPropertyBool obj "close-fd" val++constructUnixOutputStreamCloseFd :: Bool -> IO ([Char], GValue)+constructUnixOutputStreamCloseFd val = constructObjectPropertyBool "close-fd" val++data UnixOutputStreamCloseFdPropertyInfo+instance AttrInfo UnixOutputStreamCloseFdPropertyInfo where+    type AttrAllowedOps UnixOutputStreamCloseFdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint UnixOutputStreamCloseFdPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint UnixOutputStreamCloseFdPropertyInfo = UnixOutputStreamK+    type AttrGetType UnixOutputStreamCloseFdPropertyInfo = Bool+    type AttrLabel UnixOutputStreamCloseFdPropertyInfo = "UnixOutputStream::close-fd"+    attrGet _ = getUnixOutputStreamCloseFd+    attrSet _ = setUnixOutputStreamCloseFd+    attrConstruct _ = constructUnixOutputStreamCloseFd++-- VVV Prop "fd"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getUnixOutputStreamFd :: (MonadIO m, UnixOutputStreamK o) => o -> m Int32+getUnixOutputStreamFd obj = liftIO $ getObjectPropertyCInt obj "fd"++constructUnixOutputStreamFd :: Int32 -> IO ([Char], GValue)+constructUnixOutputStreamFd val = constructObjectPropertyCInt "fd" val++data UnixOutputStreamFdPropertyInfo+instance AttrInfo UnixOutputStreamFdPropertyInfo where+    type AttrAllowedOps UnixOutputStreamFdPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint UnixOutputStreamFdPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint UnixOutputStreamFdPropertyInfo = UnixOutputStreamK+    type AttrGetType UnixOutputStreamFdPropertyInfo = Int32+    type AttrLabel UnixOutputStreamFdPropertyInfo = "UnixOutputStream::fd"+    attrGet _ = getUnixOutputStreamFd+    attrSet _ = undefined+    attrConstruct _ = constructUnixOutputStreamFd++type instance AttributeList UnixOutputStream = UnixOutputStreamAttributeList+type UnixOutputStreamAttributeList = ('[ '("close-fd", UnixOutputStreamCloseFdPropertyInfo), '("fd", UnixOutputStreamFdPropertyInfo)] :: [(Symbol, *)])++type instance SignalList UnixOutputStream = UnixOutputStreamSignalList+type UnixOutputStreamSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method UnixOutputStream::new+-- method type : Constructor+-- Args : [Arg {argName = "fd", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "close_fd", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "fd", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "close_fd", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "UnixOutputStream"+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_output_stream_new" g_unix_output_stream_new :: +    Int32 ->                                -- fd : TBasicType TInt32+    CInt ->                                 -- close_fd : TBasicType TBoolean+    IO (Ptr UnixOutputStream)+++unixOutputStreamNew ::+    (MonadIO m) =>+    Int32 ->                                -- fd+    Bool ->                                 -- close_fd+    m UnixOutputStream+unixOutputStreamNew fd close_fd = liftIO $ do+    let close_fd' = (fromIntegral . fromEnum) close_fd+    result <- g_unix_output_stream_new fd close_fd'+    checkUnexpectedReturnNULL "g_unix_output_stream_new" result+    result' <- (wrapObject UnixOutputStream) result+    return result'++-- method UnixOutputStream::get_close_fd+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_output_stream_get_close_fd" g_unix_output_stream_get_close_fd :: +    Ptr UnixOutputStream ->                 -- _obj : TInterface "Gio" "UnixOutputStream"+    IO CInt+++unixOutputStreamGetCloseFd ::+    (MonadIO m, UnixOutputStreamK a) =>+    a ->                                    -- _obj+    m Bool+unixOutputStreamGetCloseFd _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_unix_output_stream_get_close_fd _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method UnixOutputStream::get_fd+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_output_stream_get_fd" g_unix_output_stream_get_fd :: +    Ptr UnixOutputStream ->                 -- _obj : TInterface "Gio" "UnixOutputStream"+    IO Int32+++unixOutputStreamGetFd ::+    (MonadIO m, UnixOutputStreamK a) =>+    a ->                                    -- _obj+    m Int32+unixOutputStreamGetFd _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_unix_output_stream_get_fd _obj'+    touchManagedPtr _obj+    return result++-- method UnixOutputStream::set_close_fd+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "close_fd", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixOutputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "close_fd", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_output_stream_set_close_fd" g_unix_output_stream_set_close_fd :: +    Ptr UnixOutputStream ->                 -- _obj : TInterface "Gio" "UnixOutputStream"+    CInt ->                                 -- close_fd : TBasicType TBoolean+    IO ()+++unixOutputStreamSetCloseFd ::+    (MonadIO m, UnixOutputStreamK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- close_fd+    m ()+unixOutputStreamSetCloseFd _obj close_fd = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let close_fd' = (fromIntegral . fromEnum) close_fd+    g_unix_output_stream_set_close_fd _obj' close_fd'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Objects/UnixOutputStream.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gio.Objects.UnixOutputStream where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype UnixOutputStream = UnixOutputStream (ForeignPtr UnixOutputStream)+instance GObject UnixOutputStream where+class GObject o => UnixOutputStreamK o+instance (GObject o, IsDescendantOf UnixOutputStream o) => UnixOutputStreamK o+data UnixOutputStreamCloseFdPropertyInfo+data UnixOutputStreamFdPropertyInfo
+ GI/Gio/Objects/UnixSocketAddress.hs view
@@ -0,0 +1,410 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.UnixSocketAddress+    ( ++-- * Exported types+    UnixSocketAddress(..)                   ,+    UnixSocketAddressK                      ,+    toUnixSocketAddress                     ,+    noUnixSocketAddress                     ,+++ -- * Methods+-- ** unixSocketAddressAbstractNamesSupported+    unixSocketAddressAbstractNamesSupported ,+++-- ** unixSocketAddressGetAddressType+    unixSocketAddressGetAddressType         ,+++-- ** unixSocketAddressGetIsAbstract+    unixSocketAddressGetIsAbstract          ,+++-- ** unixSocketAddressGetPath+    unixSocketAddressGetPath                ,+++-- ** unixSocketAddressGetPathLen+    unixSocketAddressGetPathLen             ,+++-- ** unixSocketAddressNew+    unixSocketAddressNew                    ,+++-- ** unixSocketAddressNewAbstract+    unixSocketAddressNewAbstract            ,+++-- ** unixSocketAddressNewWithType+    unixSocketAddressNewWithType            ,+++++ -- * Properties+-- ** Abstract+    UnixSocketAddressAbstractPropertyInfo   ,+    constructUnixSocketAddressAbstract      ,+    getUnixSocketAddressAbstract            ,+++-- ** AddressType+    UnixSocketAddressAddressTypePropertyInfo,+    constructUnixSocketAddressAddressType   ,+    getUnixSocketAddressAddressType         ,+++-- ** Path+    UnixSocketAddressPathPropertyInfo       ,+    constructUnixSocketAddressPath          ,+    getUnixSocketAddressPath                ,+++-- ** PathAsArray+    UnixSocketAddressPathAsArrayPropertyInfo,+    constructUnixSocketAddressPathAsArray   ,+    getUnixSocketAddressPathAsArray         ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype UnixSocketAddress = UnixSocketAddress (ForeignPtr UnixSocketAddress)+foreign import ccall "g_unix_socket_address_get_type"+    c_g_unix_socket_address_get_type :: IO GType++type instance ParentTypes UnixSocketAddress = UnixSocketAddressParentTypes+type UnixSocketAddressParentTypes = '[SocketAddress, GObject.Object, SocketConnectable]++instance GObject UnixSocketAddress where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_unix_socket_address_get_type+    ++class GObject o => UnixSocketAddressK o+instance (GObject o, IsDescendantOf UnixSocketAddress o) => UnixSocketAddressK o++toUnixSocketAddress :: UnixSocketAddressK o => o -> IO UnixSocketAddress+toUnixSocketAddress = unsafeCastTo UnixSocketAddress++noUnixSocketAddress :: Maybe UnixSocketAddress+noUnixSocketAddress = Nothing++-- VVV Prop "abstract"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getUnixSocketAddressAbstract :: (MonadIO m, UnixSocketAddressK o) => o -> m Bool+getUnixSocketAddressAbstract obj = liftIO $ getObjectPropertyBool obj "abstract"++constructUnixSocketAddressAbstract :: Bool -> IO ([Char], GValue)+constructUnixSocketAddressAbstract val = constructObjectPropertyBool "abstract" val++data UnixSocketAddressAbstractPropertyInfo+instance AttrInfo UnixSocketAddressAbstractPropertyInfo where+    type AttrAllowedOps UnixSocketAddressAbstractPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint UnixSocketAddressAbstractPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint UnixSocketAddressAbstractPropertyInfo = UnixSocketAddressK+    type AttrGetType UnixSocketAddressAbstractPropertyInfo = Bool+    type AttrLabel UnixSocketAddressAbstractPropertyInfo = "UnixSocketAddress::abstract"+    attrGet _ = getUnixSocketAddressAbstract+    attrSet _ = undefined+    attrConstruct _ = constructUnixSocketAddressAbstract++-- VVV Prop "address-type"+   -- Type: TInterface "Gio" "UnixSocketAddressType"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getUnixSocketAddressAddressType :: (MonadIO m, UnixSocketAddressK o) => o -> m UnixSocketAddressType+getUnixSocketAddressAddressType obj = liftIO $ getObjectPropertyEnum obj "address-type"++constructUnixSocketAddressAddressType :: UnixSocketAddressType -> IO ([Char], GValue)+constructUnixSocketAddressAddressType val = constructObjectPropertyEnum "address-type" val++data UnixSocketAddressAddressTypePropertyInfo+instance AttrInfo UnixSocketAddressAddressTypePropertyInfo where+    type AttrAllowedOps UnixSocketAddressAddressTypePropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint UnixSocketAddressAddressTypePropertyInfo = (~) UnixSocketAddressType+    type AttrBaseTypeConstraint UnixSocketAddressAddressTypePropertyInfo = UnixSocketAddressK+    type AttrGetType UnixSocketAddressAddressTypePropertyInfo = UnixSocketAddressType+    type AttrLabel UnixSocketAddressAddressTypePropertyInfo = "UnixSocketAddress::address-type"+    attrGet _ = getUnixSocketAddressAddressType+    attrSet _ = undefined+    attrConstruct _ = constructUnixSocketAddressAddressType++-- VVV Prop "path"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getUnixSocketAddressPath :: (MonadIO m, UnixSocketAddressK o) => o -> m T.Text+getUnixSocketAddressPath obj = liftIO $ getObjectPropertyString obj "path"++constructUnixSocketAddressPath :: T.Text -> IO ([Char], GValue)+constructUnixSocketAddressPath val = constructObjectPropertyString "path" val++data UnixSocketAddressPathPropertyInfo+instance AttrInfo UnixSocketAddressPathPropertyInfo where+    type AttrAllowedOps UnixSocketAddressPathPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint UnixSocketAddressPathPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint UnixSocketAddressPathPropertyInfo = UnixSocketAddressK+    type AttrGetType UnixSocketAddressPathPropertyInfo = T.Text+    type AttrLabel UnixSocketAddressPathPropertyInfo = "UnixSocketAddress::path"+    attrGet _ = getUnixSocketAddressPath+    attrSet _ = undefined+    attrConstruct _ = constructUnixSocketAddressPath++-- VVV Prop "path-as-array"+   -- Type: TByteArray+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getUnixSocketAddressPathAsArray :: (MonadIO m, UnixSocketAddressK o) => o -> m ByteString+getUnixSocketAddressPathAsArray obj = liftIO $ getObjectPropertyByteArray obj "path-as-array"++constructUnixSocketAddressPathAsArray :: ByteString -> IO ([Char], GValue)+constructUnixSocketAddressPathAsArray val = constructObjectPropertyByteArray "path-as-array" val++data UnixSocketAddressPathAsArrayPropertyInfo+instance AttrInfo UnixSocketAddressPathAsArrayPropertyInfo where+    type AttrAllowedOps UnixSocketAddressPathAsArrayPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint UnixSocketAddressPathAsArrayPropertyInfo = (~) ByteString+    type AttrBaseTypeConstraint UnixSocketAddressPathAsArrayPropertyInfo = UnixSocketAddressK+    type AttrGetType UnixSocketAddressPathAsArrayPropertyInfo = ByteString+    type AttrLabel UnixSocketAddressPathAsArrayPropertyInfo = "UnixSocketAddress::path-as-array"+    attrGet _ = getUnixSocketAddressPathAsArray+    attrSet _ = undefined+    attrConstruct _ = constructUnixSocketAddressPathAsArray++type instance AttributeList UnixSocketAddress = UnixSocketAddressAttributeList+type UnixSocketAddressAttributeList = ('[ '("abstract", UnixSocketAddressAbstractPropertyInfo), '("address-type", UnixSocketAddressAddressTypePropertyInfo), '("family", SocketAddressFamilyPropertyInfo), '("path", UnixSocketAddressPathPropertyInfo), '("path-as-array", UnixSocketAddressPathAsArrayPropertyInfo)] :: [(Symbol, *)])++type instance SignalList UnixSocketAddress = UnixSocketAddressSignalList+type UnixSocketAddressSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method UnixSocketAddress::new+-- method type : Constructor+-- Args : [Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "UnixSocketAddress"+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_socket_address_new" g_unix_socket_address_new :: +    CString ->                              -- path : TBasicType TUTF8+    IO (Ptr UnixSocketAddress)+++unixSocketAddressNew ::+    (MonadIO m) =>+    T.Text ->                               -- path+    m UnixSocketAddress+unixSocketAddressNew path = liftIO $ do+    path' <- textToCString path+    result <- g_unix_socket_address_new path'+    checkUnexpectedReturnNULL "g_unix_socket_address_new" result+    result' <- (wrapObject UnixSocketAddress) result+    freeMem path'+    return result'++-- method UnixSocketAddress::new_abstract+-- method type : Constructor+-- Args : [Arg {argName = "path", argType = TCArray False (-1) 1 (TBasicType TInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path_len", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "path_len", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "path", argType = TCArray False (-1) 1 (TBasicType TInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "UnixSocketAddress"+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_socket_address_new_abstract" g_unix_socket_address_new_abstract :: +    Ptr Int8 ->                             -- path : TCArray False (-1) 1 (TBasicType TInt8)+    Int32 ->                                -- path_len : TBasicType TInt32+    IO (Ptr UnixSocketAddress)++{-# DEPRECATED unixSocketAddressNewAbstract ["Use g_unix_socket_address_new_with_type()."]#-}+unixSocketAddressNewAbstract ::+    (MonadIO m) =>+    [Int8] ->                               -- path+    m UnixSocketAddress+unixSocketAddressNewAbstract path = liftIO $ do+    let path_len = fromIntegral $ length path+    path' <- packStorableArray path+    result <- g_unix_socket_address_new_abstract path' path_len+    checkUnexpectedReturnNULL "g_unix_socket_address_new_abstract" result+    result' <- (wrapObject UnixSocketAddress) result+    freeMem path'+    return result'++-- method UnixSocketAddress::new_with_type+-- method type : Constructor+-- Args : [Arg {argName = "path", argType = TCArray False (-1) 1 (TBasicType TInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path_len", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "Gio" "UnixSocketAddressType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "path_len", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "path", argType = TCArray False (-1) 1 (TBasicType TInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "Gio" "UnixSocketAddressType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "UnixSocketAddress"+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_socket_address_new_with_type" g_unix_socket_address_new_with_type :: +    Ptr Int8 ->                             -- path : TCArray False (-1) 1 (TBasicType TInt8)+    Int32 ->                                -- path_len : TBasicType TInt32+    CUInt ->                                -- type : TInterface "Gio" "UnixSocketAddressType"+    IO (Ptr UnixSocketAddress)+++unixSocketAddressNewWithType ::+    (MonadIO m) =>+    [Int8] ->                               -- path+    UnixSocketAddressType ->                -- type+    m UnixSocketAddress+unixSocketAddressNewWithType path type_ = liftIO $ do+    let path_len = fromIntegral $ length path+    path' <- packStorableArray path+    let type_' = (fromIntegral . fromEnum) type_+    result <- g_unix_socket_address_new_with_type path' path_len type_'+    checkUnexpectedReturnNULL "g_unix_socket_address_new_with_type" result+    result' <- (wrapObject UnixSocketAddress) result+    freeMem path'+    return result'++-- method UnixSocketAddress::get_address_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixSocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixSocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "UnixSocketAddressType"+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_socket_address_get_address_type" g_unix_socket_address_get_address_type :: +    Ptr UnixSocketAddress ->                -- _obj : TInterface "Gio" "UnixSocketAddress"+    IO CUInt+++unixSocketAddressGetAddressType ::+    (MonadIO m, UnixSocketAddressK a) =>+    a ->                                    -- _obj+    m UnixSocketAddressType+unixSocketAddressGetAddressType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_unix_socket_address_get_address_type _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method UnixSocketAddress::get_is_abstract+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixSocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixSocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_socket_address_get_is_abstract" g_unix_socket_address_get_is_abstract :: +    Ptr UnixSocketAddress ->                -- _obj : TInterface "Gio" "UnixSocketAddress"+    IO CInt++{-# DEPRECATED unixSocketAddressGetIsAbstract ["Use g_unix_socket_address_get_address_type()"]#-}+unixSocketAddressGetIsAbstract ::+    (MonadIO m, UnixSocketAddressK a) =>+    a ->                                    -- _obj+    m Bool+unixSocketAddressGetIsAbstract _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_unix_socket_address_get_is_abstract _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method UnixSocketAddress::get_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixSocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixSocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_socket_address_get_path" g_unix_socket_address_get_path :: +    Ptr UnixSocketAddress ->                -- _obj : TInterface "Gio" "UnixSocketAddress"+    IO CString+++unixSocketAddressGetPath ::+    (MonadIO m, UnixSocketAddressK a) =>+    a ->                                    -- _obj+    m T.Text+unixSocketAddressGetPath _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_unix_socket_address_get_path _obj'+    checkUnexpectedReturnNULL "g_unix_socket_address_get_path" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method UnixSocketAddress::get_path_len+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixSocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixSocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_socket_address_get_path_len" g_unix_socket_address_get_path_len :: +    Ptr UnixSocketAddress ->                -- _obj : TInterface "Gio" "UnixSocketAddress"+    IO Word64+++unixSocketAddressGetPathLen ::+    (MonadIO m, UnixSocketAddressK a) =>+    a ->                                    -- _obj+    m Word64+unixSocketAddressGetPathLen _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_unix_socket_address_get_path_len _obj'+    touchManagedPtr _obj+    return result++-- method UnixSocketAddress::abstract_names_supported+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_socket_address_abstract_names_supported" g_unix_socket_address_abstract_names_supported :: +    IO CInt+++unixSocketAddressAbstractNamesSupported ::+    (MonadIO m) =>+    m Bool+unixSocketAddressAbstractNamesSupported  = liftIO $ do+    result <- g_unix_socket_address_abstract_names_supported+    let result' = (/= 0) result+    return result'++
+ GI/Gio/Objects/UnixSocketAddress.hs-boot view
@@ -0,0 +1,17 @@+module GI.Gio.Objects.UnixSocketAddress where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype UnixSocketAddress = UnixSocketAddress (ForeignPtr UnixSocketAddress)+instance GObject UnixSocketAddress where+class GObject o => UnixSocketAddressK o+instance (GObject o, IsDescendantOf UnixSocketAddress o) => UnixSocketAddressK o+data UnixSocketAddressAbstractPropertyInfo+data UnixSocketAddressAddressTypePropertyInfo+data UnixSocketAddressPathPropertyInfo+data UnixSocketAddressPathAsArrayPropertyInfo
+ GI/Gio/Objects/Vfs.hs view
@@ -0,0 +1,274 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.Vfs+    ( ++-- * Exported types+    Vfs(..)                                 ,+    VfsK                                    ,+    toVfs                                   ,+    noVfs                                   ,+++ -- * Methods+-- ** vfsGetDefault+    vfsGetDefault                           ,+++-- ** vfsGetFileForPath+    vfsGetFileForPath                       ,+++-- ** vfsGetFileForUri+    vfsGetFileForUri                        ,+++-- ** vfsGetLocal+    vfsGetLocal                             ,+++-- ** vfsGetSupportedUriSchemes+    vfsGetSupportedUriSchemes               ,+++-- ** vfsIsActive+    vfsIsActive                             ,+++-- ** vfsParseName+    vfsParseName                            ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype Vfs = Vfs (ForeignPtr Vfs)+foreign import ccall "g_vfs_get_type"+    c_g_vfs_get_type :: IO GType++type instance ParentTypes Vfs = VfsParentTypes+type VfsParentTypes = '[GObject.Object]++instance GObject Vfs where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_vfs_get_type+    ++class GObject o => VfsK o+instance (GObject o, IsDescendantOf Vfs o) => VfsK o++toVfs :: VfsK o => o -> IO Vfs+toVfs = unsafeCastTo Vfs++noVfs :: Maybe Vfs+noVfs = Nothing++type instance AttributeList Vfs = VfsAttributeList+type VfsAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList Vfs = VfsSignalList+type VfsSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Vfs::get_file_for_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Vfs", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Vfs", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "File"+-- throws : False+-- Skip return : False++foreign import ccall "g_vfs_get_file_for_path" g_vfs_get_file_for_path :: +    Ptr Vfs ->                              -- _obj : TInterface "Gio" "Vfs"+    CString ->                              -- path : TBasicType TUTF8+    IO (Ptr File)+++vfsGetFileForPath ::+    (MonadIO m, VfsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- path+    m File+vfsGetFileForPath _obj path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    path' <- textToCString path+    result <- g_vfs_get_file_for_path _obj' path'+    checkUnexpectedReturnNULL "g_vfs_get_file_for_path" result+    result' <- (wrapObject File) result+    touchManagedPtr _obj+    freeMem path'+    return result'++-- method Vfs::get_file_for_uri+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Vfs", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Vfs", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "File"+-- throws : False+-- Skip return : False++foreign import ccall "g_vfs_get_file_for_uri" g_vfs_get_file_for_uri :: +    Ptr Vfs ->                              -- _obj : TInterface "Gio" "Vfs"+    CString ->                              -- uri : TBasicType TUTF8+    IO (Ptr File)+++vfsGetFileForUri ::+    (MonadIO m, VfsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- uri+    m File+vfsGetFileForUri _obj uri = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    uri' <- textToCString uri+    result <- g_vfs_get_file_for_uri _obj' uri'+    checkUnexpectedReturnNULL "g_vfs_get_file_for_uri" result+    result' <- (wrapObject File) result+    touchManagedPtr _obj+    freeMem uri'+    return result'++-- method Vfs::get_supported_uri_schemes+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Vfs", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Vfs", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_vfs_get_supported_uri_schemes" g_vfs_get_supported_uri_schemes :: +    Ptr Vfs ->                              -- _obj : TInterface "Gio" "Vfs"+    IO (Ptr CString)+++vfsGetSupportedUriSchemes ::+    (MonadIO m, VfsK a) =>+    a ->                                    -- _obj+    m [T.Text]+vfsGetSupportedUriSchemes _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_vfs_get_supported_uri_schemes _obj'+    checkUnexpectedReturnNULL "g_vfs_get_supported_uri_schemes" result+    result' <- unpackZeroTerminatedUTF8CArray result+    touchManagedPtr _obj+    return result'++-- method Vfs::is_active+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Vfs", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Vfs", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_vfs_is_active" g_vfs_is_active :: +    Ptr Vfs ->                              -- _obj : TInterface "Gio" "Vfs"+    IO CInt+++vfsIsActive ::+    (MonadIO m, VfsK a) =>+    a ->                                    -- _obj+    m Bool+vfsIsActive _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_vfs_is_active _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Vfs::parse_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Vfs", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parse_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Vfs", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parse_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "File"+-- throws : False+-- Skip return : False++foreign import ccall "g_vfs_parse_name" g_vfs_parse_name :: +    Ptr Vfs ->                              -- _obj : TInterface "Gio" "Vfs"+    CString ->                              -- parse_name : TBasicType TUTF8+    IO (Ptr File)+++vfsParseName ::+    (MonadIO m, VfsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- parse_name+    m File+vfsParseName _obj parse_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    parse_name' <- textToCString parse_name+    result <- g_vfs_parse_name _obj' parse_name'+    checkUnexpectedReturnNULL "g_vfs_parse_name" result+    result' <- (wrapObject File) result+    touchManagedPtr _obj+    freeMem parse_name'+    return result'++-- method Vfs::get_default+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gio" "Vfs"+-- throws : False+-- Skip return : False++foreign import ccall "g_vfs_get_default" g_vfs_get_default :: +    IO (Ptr Vfs)+++vfsGetDefault ::+    (MonadIO m) =>+    m Vfs+vfsGetDefault  = liftIO $ do+    result <- g_vfs_get_default+    checkUnexpectedReturnNULL "g_vfs_get_default" result+    result' <- (newObject Vfs) result+    return result'++-- method Vfs::get_local+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gio" "Vfs"+-- throws : False+-- Skip return : False++foreign import ccall "g_vfs_get_local" g_vfs_get_local :: +    IO (Ptr Vfs)+++vfsGetLocal ::+    (MonadIO m) =>+    m Vfs+vfsGetLocal  = liftIO $ do+    result <- g_vfs_get_local+    checkUnexpectedReturnNULL "g_vfs_get_local" result+    result' <- (newObject Vfs) result+    return result'++
+ GI/Gio/Objects/Vfs.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gio.Objects.Vfs where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Vfs = Vfs (ForeignPtr Vfs)+instance GObject Vfs where+class GObject o => VfsK o+instance (GObject o, IsDescendantOf Vfs o) => VfsK o
+ GI/Gio/Objects/VolumeMonitor.hs view
@@ -0,0 +1,992 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.VolumeMonitor+    ( ++-- * Exported types+    VolumeMonitor(..)                       ,+    VolumeMonitorK                          ,+    toVolumeMonitor                         ,+    noVolumeMonitor                         ,+++ -- * Methods+-- ** volumeMonitorAdoptOrphanMount+    volumeMonitorAdoptOrphanMount           ,+++-- ** volumeMonitorGet+    volumeMonitorGet                        ,+++-- ** volumeMonitorGetConnectedDrives+    volumeMonitorGetConnectedDrives         ,+++-- ** volumeMonitorGetMountForUuid+    volumeMonitorGetMountForUuid            ,+++-- ** volumeMonitorGetMounts+    volumeMonitorGetMounts                  ,+++-- ** volumeMonitorGetVolumeForUuid+    volumeMonitorGetVolumeForUuid           ,+++-- ** volumeMonitorGetVolumes+    volumeMonitorGetVolumes                 ,+++++ -- * Signals+-- ** DriveChanged+    VolumeMonitorDriveChangedCallback       ,+    VolumeMonitorDriveChangedCallbackC      ,+    VolumeMonitorDriveChangedSignalInfo     ,+    afterVolumeMonitorDriveChanged          ,+    mkVolumeMonitorDriveChangedCallback     ,+    noVolumeMonitorDriveChangedCallback     ,+    onVolumeMonitorDriveChanged             ,+    volumeMonitorDriveChangedCallbackWrapper,+    volumeMonitorDriveChangedClosure        ,+++-- ** DriveConnected+    VolumeMonitorDriveConnectedCallback     ,+    VolumeMonitorDriveConnectedCallbackC    ,+    VolumeMonitorDriveConnectedSignalInfo   ,+    afterVolumeMonitorDriveConnected        ,+    mkVolumeMonitorDriveConnectedCallback   ,+    noVolumeMonitorDriveConnectedCallback   ,+    onVolumeMonitorDriveConnected           ,+    volumeMonitorDriveConnectedCallbackWrapper,+    volumeMonitorDriveConnectedClosure      ,+++-- ** DriveDisconnected+    VolumeMonitorDriveDisconnectedCallback  ,+    VolumeMonitorDriveDisconnectedCallbackC ,+    VolumeMonitorDriveDisconnectedSignalInfo,+    afterVolumeMonitorDriveDisconnected     ,+    mkVolumeMonitorDriveDisconnectedCallback,+    noVolumeMonitorDriveDisconnectedCallback,+    onVolumeMonitorDriveDisconnected        ,+    volumeMonitorDriveDisconnectedCallbackWrapper,+    volumeMonitorDriveDisconnectedClosure   ,+++-- ** DriveEjectButton+    VolumeMonitorDriveEjectButtonCallback   ,+    VolumeMonitorDriveEjectButtonCallbackC  ,+    VolumeMonitorDriveEjectButtonSignalInfo ,+    afterVolumeMonitorDriveEjectButton      ,+    mkVolumeMonitorDriveEjectButtonCallback ,+    noVolumeMonitorDriveEjectButtonCallback ,+    onVolumeMonitorDriveEjectButton         ,+    volumeMonitorDriveEjectButtonCallbackWrapper,+    volumeMonitorDriveEjectButtonClosure    ,+++-- ** DriveStopButton+    VolumeMonitorDriveStopButtonCallback    ,+    VolumeMonitorDriveStopButtonCallbackC   ,+    VolumeMonitorDriveStopButtonSignalInfo  ,+    afterVolumeMonitorDriveStopButton       ,+    mkVolumeMonitorDriveStopButtonCallback  ,+    noVolumeMonitorDriveStopButtonCallback  ,+    onVolumeMonitorDriveStopButton          ,+    volumeMonitorDriveStopButtonCallbackWrapper,+    volumeMonitorDriveStopButtonClosure     ,+++-- ** MountAdded+    VolumeMonitorMountAddedCallback         ,+    VolumeMonitorMountAddedCallbackC        ,+    VolumeMonitorMountAddedSignalInfo       ,+    afterVolumeMonitorMountAdded            ,+    mkVolumeMonitorMountAddedCallback       ,+    noVolumeMonitorMountAddedCallback       ,+    onVolumeMonitorMountAdded               ,+    volumeMonitorMountAddedCallbackWrapper  ,+    volumeMonitorMountAddedClosure          ,+++-- ** MountChanged+    VolumeMonitorMountChangedCallback       ,+    VolumeMonitorMountChangedCallbackC      ,+    VolumeMonitorMountChangedSignalInfo     ,+    afterVolumeMonitorMountChanged          ,+    mkVolumeMonitorMountChangedCallback     ,+    noVolumeMonitorMountChangedCallback     ,+    onVolumeMonitorMountChanged             ,+    volumeMonitorMountChangedCallbackWrapper,+    volumeMonitorMountChangedClosure        ,+++-- ** MountPreUnmount+    VolumeMonitorMountPreUnmountCallback    ,+    VolumeMonitorMountPreUnmountCallbackC   ,+    VolumeMonitorMountPreUnmountSignalInfo  ,+    afterVolumeMonitorMountPreUnmount       ,+    mkVolumeMonitorMountPreUnmountCallback  ,+    noVolumeMonitorMountPreUnmountCallback  ,+    onVolumeMonitorMountPreUnmount          ,+    volumeMonitorMountPreUnmountCallbackWrapper,+    volumeMonitorMountPreUnmountClosure     ,+++-- ** MountRemoved+    VolumeMonitorMountRemovedCallback       ,+    VolumeMonitorMountRemovedCallbackC      ,+    VolumeMonitorMountRemovedSignalInfo     ,+    afterVolumeMonitorMountRemoved          ,+    mkVolumeMonitorMountRemovedCallback     ,+    noVolumeMonitorMountRemovedCallback     ,+    onVolumeMonitorMountRemoved             ,+    volumeMonitorMountRemovedCallbackWrapper,+    volumeMonitorMountRemovedClosure        ,+++-- ** VolumeAdded+    VolumeMonitorVolumeAddedCallback        ,+    VolumeMonitorVolumeAddedCallbackC       ,+    VolumeMonitorVolumeAddedSignalInfo      ,+    afterVolumeMonitorVolumeAdded           ,+    mkVolumeMonitorVolumeAddedCallback      ,+    noVolumeMonitorVolumeAddedCallback      ,+    onVolumeMonitorVolumeAdded              ,+    volumeMonitorVolumeAddedCallbackWrapper ,+    volumeMonitorVolumeAddedClosure         ,+++-- ** VolumeChanged+    VolumeMonitorVolumeChangedCallback      ,+    VolumeMonitorVolumeChangedCallbackC     ,+    VolumeMonitorVolumeChangedSignalInfo    ,+    afterVolumeMonitorVolumeChanged         ,+    mkVolumeMonitorVolumeChangedCallback    ,+    noVolumeMonitorVolumeChangedCallback    ,+    onVolumeMonitorVolumeChanged            ,+    volumeMonitorVolumeChangedCallbackWrapper,+    volumeMonitorVolumeChangedClosure       ,+++-- ** VolumeRemoved+    VolumeMonitorVolumeRemovedCallback      ,+    VolumeMonitorVolumeRemovedCallbackC     ,+    VolumeMonitorVolumeRemovedSignalInfo    ,+    afterVolumeMonitorVolumeRemoved         ,+    mkVolumeMonitorVolumeRemovedCallback    ,+    noVolumeMonitorVolumeRemovedCallback    ,+    onVolumeMonitorVolumeRemoved            ,+    volumeMonitorVolumeRemovedCallbackWrapper,+    volumeMonitorVolumeRemovedClosure       ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype VolumeMonitor = VolumeMonitor (ForeignPtr VolumeMonitor)+foreign import ccall "g_volume_monitor_get_type"+    c_g_volume_monitor_get_type :: IO GType++type instance ParentTypes VolumeMonitor = VolumeMonitorParentTypes+type VolumeMonitorParentTypes = '[GObject.Object]++instance GObject VolumeMonitor where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_volume_monitor_get_type+    ++class GObject o => VolumeMonitorK o+instance (GObject o, IsDescendantOf VolumeMonitor o) => VolumeMonitorK o++toVolumeMonitor :: VolumeMonitorK o => o -> IO VolumeMonitor+toVolumeMonitor = unsafeCastTo VolumeMonitor++noVolumeMonitor :: Maybe VolumeMonitor+noVolumeMonitor = Nothing++-- signal VolumeMonitor::drive-changed+type VolumeMonitorDriveChangedCallback =+    Drive ->+    IO ()++noVolumeMonitorDriveChangedCallback :: Maybe VolumeMonitorDriveChangedCallback+noVolumeMonitorDriveChangedCallback = Nothing++type VolumeMonitorDriveChangedCallbackC =+    Ptr () ->                               -- object+    Ptr Drive ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkVolumeMonitorDriveChangedCallback :: VolumeMonitorDriveChangedCallbackC -> IO (FunPtr VolumeMonitorDriveChangedCallbackC)++volumeMonitorDriveChangedClosure :: VolumeMonitorDriveChangedCallback -> IO Closure+volumeMonitorDriveChangedClosure cb = newCClosure =<< mkVolumeMonitorDriveChangedCallback wrapped+    where wrapped = volumeMonitorDriveChangedCallbackWrapper cb++volumeMonitorDriveChangedCallbackWrapper ::+    VolumeMonitorDriveChangedCallback ->+    Ptr () ->+    Ptr Drive ->+    Ptr () ->+    IO ()+volumeMonitorDriveChangedCallbackWrapper _cb _ drive _ = do+    drive' <- (newObject Drive) drive+    _cb  drive'++onVolumeMonitorDriveChanged :: (GObject a, MonadIO m) => a -> VolumeMonitorDriveChangedCallback -> m SignalHandlerId+onVolumeMonitorDriveChanged obj cb = liftIO $ connectVolumeMonitorDriveChanged obj cb SignalConnectBefore+afterVolumeMonitorDriveChanged :: (GObject a, MonadIO m) => a -> VolumeMonitorDriveChangedCallback -> m SignalHandlerId+afterVolumeMonitorDriveChanged obj cb = connectVolumeMonitorDriveChanged obj cb SignalConnectAfter++connectVolumeMonitorDriveChanged :: (GObject a, MonadIO m) =>+                                    a -> VolumeMonitorDriveChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectVolumeMonitorDriveChanged obj cb after = liftIO $ do+    cb' <- mkVolumeMonitorDriveChangedCallback (volumeMonitorDriveChangedCallbackWrapper cb)+    connectSignalFunPtr obj "drive-changed" cb' after++-- signal VolumeMonitor::drive-connected+type VolumeMonitorDriveConnectedCallback =+    Drive ->+    IO ()++noVolumeMonitorDriveConnectedCallback :: Maybe VolumeMonitorDriveConnectedCallback+noVolumeMonitorDriveConnectedCallback = Nothing++type VolumeMonitorDriveConnectedCallbackC =+    Ptr () ->                               -- object+    Ptr Drive ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkVolumeMonitorDriveConnectedCallback :: VolumeMonitorDriveConnectedCallbackC -> IO (FunPtr VolumeMonitorDriveConnectedCallbackC)++volumeMonitorDriveConnectedClosure :: VolumeMonitorDriveConnectedCallback -> IO Closure+volumeMonitorDriveConnectedClosure cb = newCClosure =<< mkVolumeMonitorDriveConnectedCallback wrapped+    where wrapped = volumeMonitorDriveConnectedCallbackWrapper cb++volumeMonitorDriveConnectedCallbackWrapper ::+    VolumeMonitorDriveConnectedCallback ->+    Ptr () ->+    Ptr Drive ->+    Ptr () ->+    IO ()+volumeMonitorDriveConnectedCallbackWrapper _cb _ drive _ = do+    drive' <- (newObject Drive) drive+    _cb  drive'++onVolumeMonitorDriveConnected :: (GObject a, MonadIO m) => a -> VolumeMonitorDriveConnectedCallback -> m SignalHandlerId+onVolumeMonitorDriveConnected obj cb = liftIO $ connectVolumeMonitorDriveConnected obj cb SignalConnectBefore+afterVolumeMonitorDriveConnected :: (GObject a, MonadIO m) => a -> VolumeMonitorDriveConnectedCallback -> m SignalHandlerId+afterVolumeMonitorDriveConnected obj cb = connectVolumeMonitorDriveConnected obj cb SignalConnectAfter++connectVolumeMonitorDriveConnected :: (GObject a, MonadIO m) =>+                                      a -> VolumeMonitorDriveConnectedCallback -> SignalConnectMode -> m SignalHandlerId+connectVolumeMonitorDriveConnected obj cb after = liftIO $ do+    cb' <- mkVolumeMonitorDriveConnectedCallback (volumeMonitorDriveConnectedCallbackWrapper cb)+    connectSignalFunPtr obj "drive-connected" cb' after++-- signal VolumeMonitor::drive-disconnected+type VolumeMonitorDriveDisconnectedCallback =+    Drive ->+    IO ()++noVolumeMonitorDriveDisconnectedCallback :: Maybe VolumeMonitorDriveDisconnectedCallback+noVolumeMonitorDriveDisconnectedCallback = Nothing++type VolumeMonitorDriveDisconnectedCallbackC =+    Ptr () ->                               -- object+    Ptr Drive ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkVolumeMonitorDriveDisconnectedCallback :: VolumeMonitorDriveDisconnectedCallbackC -> IO (FunPtr VolumeMonitorDriveDisconnectedCallbackC)++volumeMonitorDriveDisconnectedClosure :: VolumeMonitorDriveDisconnectedCallback -> IO Closure+volumeMonitorDriveDisconnectedClosure cb = newCClosure =<< mkVolumeMonitorDriveDisconnectedCallback wrapped+    where wrapped = volumeMonitorDriveDisconnectedCallbackWrapper cb++volumeMonitorDriveDisconnectedCallbackWrapper ::+    VolumeMonitorDriveDisconnectedCallback ->+    Ptr () ->+    Ptr Drive ->+    Ptr () ->+    IO ()+volumeMonitorDriveDisconnectedCallbackWrapper _cb _ drive _ = do+    drive' <- (newObject Drive) drive+    _cb  drive'++onVolumeMonitorDriveDisconnected :: (GObject a, MonadIO m) => a -> VolumeMonitorDriveDisconnectedCallback -> m SignalHandlerId+onVolumeMonitorDriveDisconnected obj cb = liftIO $ connectVolumeMonitorDriveDisconnected obj cb SignalConnectBefore+afterVolumeMonitorDriveDisconnected :: (GObject a, MonadIO m) => a -> VolumeMonitorDriveDisconnectedCallback -> m SignalHandlerId+afterVolumeMonitorDriveDisconnected obj cb = connectVolumeMonitorDriveDisconnected obj cb SignalConnectAfter++connectVolumeMonitorDriveDisconnected :: (GObject a, MonadIO m) =>+                                         a -> VolumeMonitorDriveDisconnectedCallback -> SignalConnectMode -> m SignalHandlerId+connectVolumeMonitorDriveDisconnected obj cb after = liftIO $ do+    cb' <- mkVolumeMonitorDriveDisconnectedCallback (volumeMonitorDriveDisconnectedCallbackWrapper cb)+    connectSignalFunPtr obj "drive-disconnected" cb' after++-- signal VolumeMonitor::drive-eject-button+type VolumeMonitorDriveEjectButtonCallback =+    Drive ->+    IO ()++noVolumeMonitorDriveEjectButtonCallback :: Maybe VolumeMonitorDriveEjectButtonCallback+noVolumeMonitorDriveEjectButtonCallback = Nothing++type VolumeMonitorDriveEjectButtonCallbackC =+    Ptr () ->                               -- object+    Ptr Drive ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkVolumeMonitorDriveEjectButtonCallback :: VolumeMonitorDriveEjectButtonCallbackC -> IO (FunPtr VolumeMonitorDriveEjectButtonCallbackC)++volumeMonitorDriveEjectButtonClosure :: VolumeMonitorDriveEjectButtonCallback -> IO Closure+volumeMonitorDriveEjectButtonClosure cb = newCClosure =<< mkVolumeMonitorDriveEjectButtonCallback wrapped+    where wrapped = volumeMonitorDriveEjectButtonCallbackWrapper cb++volumeMonitorDriveEjectButtonCallbackWrapper ::+    VolumeMonitorDriveEjectButtonCallback ->+    Ptr () ->+    Ptr Drive ->+    Ptr () ->+    IO ()+volumeMonitorDriveEjectButtonCallbackWrapper _cb _ drive _ = do+    drive' <- (newObject Drive) drive+    _cb  drive'++onVolumeMonitorDriveEjectButton :: (GObject a, MonadIO m) => a -> VolumeMonitorDriveEjectButtonCallback -> m SignalHandlerId+onVolumeMonitorDriveEjectButton obj cb = liftIO $ connectVolumeMonitorDriveEjectButton obj cb SignalConnectBefore+afterVolumeMonitorDriveEjectButton :: (GObject a, MonadIO m) => a -> VolumeMonitorDriveEjectButtonCallback -> m SignalHandlerId+afterVolumeMonitorDriveEjectButton obj cb = connectVolumeMonitorDriveEjectButton obj cb SignalConnectAfter++connectVolumeMonitorDriveEjectButton :: (GObject a, MonadIO m) =>+                                        a -> VolumeMonitorDriveEjectButtonCallback -> SignalConnectMode -> m SignalHandlerId+connectVolumeMonitorDriveEjectButton obj cb after = liftIO $ do+    cb' <- mkVolumeMonitorDriveEjectButtonCallback (volumeMonitorDriveEjectButtonCallbackWrapper cb)+    connectSignalFunPtr obj "drive-eject-button" cb' after++-- signal VolumeMonitor::drive-stop-button+type VolumeMonitorDriveStopButtonCallback =+    Drive ->+    IO ()++noVolumeMonitorDriveStopButtonCallback :: Maybe VolumeMonitorDriveStopButtonCallback+noVolumeMonitorDriveStopButtonCallback = Nothing++type VolumeMonitorDriveStopButtonCallbackC =+    Ptr () ->                               -- object+    Ptr Drive ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkVolumeMonitorDriveStopButtonCallback :: VolumeMonitorDriveStopButtonCallbackC -> IO (FunPtr VolumeMonitorDriveStopButtonCallbackC)++volumeMonitorDriveStopButtonClosure :: VolumeMonitorDriveStopButtonCallback -> IO Closure+volumeMonitorDriveStopButtonClosure cb = newCClosure =<< mkVolumeMonitorDriveStopButtonCallback wrapped+    where wrapped = volumeMonitorDriveStopButtonCallbackWrapper cb++volumeMonitorDriveStopButtonCallbackWrapper ::+    VolumeMonitorDriveStopButtonCallback ->+    Ptr () ->+    Ptr Drive ->+    Ptr () ->+    IO ()+volumeMonitorDriveStopButtonCallbackWrapper _cb _ drive _ = do+    drive' <- (newObject Drive) drive+    _cb  drive'++onVolumeMonitorDriveStopButton :: (GObject a, MonadIO m) => a -> VolumeMonitorDriveStopButtonCallback -> m SignalHandlerId+onVolumeMonitorDriveStopButton obj cb = liftIO $ connectVolumeMonitorDriveStopButton obj cb SignalConnectBefore+afterVolumeMonitorDriveStopButton :: (GObject a, MonadIO m) => a -> VolumeMonitorDriveStopButtonCallback -> m SignalHandlerId+afterVolumeMonitorDriveStopButton obj cb = connectVolumeMonitorDriveStopButton obj cb SignalConnectAfter++connectVolumeMonitorDriveStopButton :: (GObject a, MonadIO m) =>+                                       a -> VolumeMonitorDriveStopButtonCallback -> SignalConnectMode -> m SignalHandlerId+connectVolumeMonitorDriveStopButton obj cb after = liftIO $ do+    cb' <- mkVolumeMonitorDriveStopButtonCallback (volumeMonitorDriveStopButtonCallbackWrapper cb)+    connectSignalFunPtr obj "drive-stop-button" cb' after++-- signal VolumeMonitor::mount-added+type VolumeMonitorMountAddedCallback =+    Mount ->+    IO ()++noVolumeMonitorMountAddedCallback :: Maybe VolumeMonitorMountAddedCallback+noVolumeMonitorMountAddedCallback = Nothing++type VolumeMonitorMountAddedCallbackC =+    Ptr () ->                               -- object+    Ptr Mount ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkVolumeMonitorMountAddedCallback :: VolumeMonitorMountAddedCallbackC -> IO (FunPtr VolumeMonitorMountAddedCallbackC)++volumeMonitorMountAddedClosure :: VolumeMonitorMountAddedCallback -> IO Closure+volumeMonitorMountAddedClosure cb = newCClosure =<< mkVolumeMonitorMountAddedCallback wrapped+    where wrapped = volumeMonitorMountAddedCallbackWrapper cb++volumeMonitorMountAddedCallbackWrapper ::+    VolumeMonitorMountAddedCallback ->+    Ptr () ->+    Ptr Mount ->+    Ptr () ->+    IO ()+volumeMonitorMountAddedCallbackWrapper _cb _ mount _ = do+    mount' <- (newObject Mount) mount+    _cb  mount'++onVolumeMonitorMountAdded :: (GObject a, MonadIO m) => a -> VolumeMonitorMountAddedCallback -> m SignalHandlerId+onVolumeMonitorMountAdded obj cb = liftIO $ connectVolumeMonitorMountAdded obj cb SignalConnectBefore+afterVolumeMonitorMountAdded :: (GObject a, MonadIO m) => a -> VolumeMonitorMountAddedCallback -> m SignalHandlerId+afterVolumeMonitorMountAdded obj cb = connectVolumeMonitorMountAdded obj cb SignalConnectAfter++connectVolumeMonitorMountAdded :: (GObject a, MonadIO m) =>+                                  a -> VolumeMonitorMountAddedCallback -> SignalConnectMode -> m SignalHandlerId+connectVolumeMonitorMountAdded obj cb after = liftIO $ do+    cb' <- mkVolumeMonitorMountAddedCallback (volumeMonitorMountAddedCallbackWrapper cb)+    connectSignalFunPtr obj "mount-added" cb' after++-- signal VolumeMonitor::mount-changed+type VolumeMonitorMountChangedCallback =+    Mount ->+    IO ()++noVolumeMonitorMountChangedCallback :: Maybe VolumeMonitorMountChangedCallback+noVolumeMonitorMountChangedCallback = Nothing++type VolumeMonitorMountChangedCallbackC =+    Ptr () ->                               -- object+    Ptr Mount ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkVolumeMonitorMountChangedCallback :: VolumeMonitorMountChangedCallbackC -> IO (FunPtr VolumeMonitorMountChangedCallbackC)++volumeMonitorMountChangedClosure :: VolumeMonitorMountChangedCallback -> IO Closure+volumeMonitorMountChangedClosure cb = newCClosure =<< mkVolumeMonitorMountChangedCallback wrapped+    where wrapped = volumeMonitorMountChangedCallbackWrapper cb++volumeMonitorMountChangedCallbackWrapper ::+    VolumeMonitorMountChangedCallback ->+    Ptr () ->+    Ptr Mount ->+    Ptr () ->+    IO ()+volumeMonitorMountChangedCallbackWrapper _cb _ mount _ = do+    mount' <- (newObject Mount) mount+    _cb  mount'++onVolumeMonitorMountChanged :: (GObject a, MonadIO m) => a -> VolumeMonitorMountChangedCallback -> m SignalHandlerId+onVolumeMonitorMountChanged obj cb = liftIO $ connectVolumeMonitorMountChanged obj cb SignalConnectBefore+afterVolumeMonitorMountChanged :: (GObject a, MonadIO m) => a -> VolumeMonitorMountChangedCallback -> m SignalHandlerId+afterVolumeMonitorMountChanged obj cb = connectVolumeMonitorMountChanged obj cb SignalConnectAfter++connectVolumeMonitorMountChanged :: (GObject a, MonadIO m) =>+                                    a -> VolumeMonitorMountChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectVolumeMonitorMountChanged obj cb after = liftIO $ do+    cb' <- mkVolumeMonitorMountChangedCallback (volumeMonitorMountChangedCallbackWrapper cb)+    connectSignalFunPtr obj "mount-changed" cb' after++-- signal VolumeMonitor::mount-pre-unmount+type VolumeMonitorMountPreUnmountCallback =+    Mount ->+    IO ()++noVolumeMonitorMountPreUnmountCallback :: Maybe VolumeMonitorMountPreUnmountCallback+noVolumeMonitorMountPreUnmountCallback = Nothing++type VolumeMonitorMountPreUnmountCallbackC =+    Ptr () ->                               -- object+    Ptr Mount ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkVolumeMonitorMountPreUnmountCallback :: VolumeMonitorMountPreUnmountCallbackC -> IO (FunPtr VolumeMonitorMountPreUnmountCallbackC)++volumeMonitorMountPreUnmountClosure :: VolumeMonitorMountPreUnmountCallback -> IO Closure+volumeMonitorMountPreUnmountClosure cb = newCClosure =<< mkVolumeMonitorMountPreUnmountCallback wrapped+    where wrapped = volumeMonitorMountPreUnmountCallbackWrapper cb++volumeMonitorMountPreUnmountCallbackWrapper ::+    VolumeMonitorMountPreUnmountCallback ->+    Ptr () ->+    Ptr Mount ->+    Ptr () ->+    IO ()+volumeMonitorMountPreUnmountCallbackWrapper _cb _ mount _ = do+    mount' <- (newObject Mount) mount+    _cb  mount'++onVolumeMonitorMountPreUnmount :: (GObject a, MonadIO m) => a -> VolumeMonitorMountPreUnmountCallback -> m SignalHandlerId+onVolumeMonitorMountPreUnmount obj cb = liftIO $ connectVolumeMonitorMountPreUnmount obj cb SignalConnectBefore+afterVolumeMonitorMountPreUnmount :: (GObject a, MonadIO m) => a -> VolumeMonitorMountPreUnmountCallback -> m SignalHandlerId+afterVolumeMonitorMountPreUnmount obj cb = connectVolumeMonitorMountPreUnmount obj cb SignalConnectAfter++connectVolumeMonitorMountPreUnmount :: (GObject a, MonadIO m) =>+                                       a -> VolumeMonitorMountPreUnmountCallback -> SignalConnectMode -> m SignalHandlerId+connectVolumeMonitorMountPreUnmount obj cb after = liftIO $ do+    cb' <- mkVolumeMonitorMountPreUnmountCallback (volumeMonitorMountPreUnmountCallbackWrapper cb)+    connectSignalFunPtr obj "mount-pre-unmount" cb' after++-- signal VolumeMonitor::mount-removed+type VolumeMonitorMountRemovedCallback =+    Mount ->+    IO ()++noVolumeMonitorMountRemovedCallback :: Maybe VolumeMonitorMountRemovedCallback+noVolumeMonitorMountRemovedCallback = Nothing++type VolumeMonitorMountRemovedCallbackC =+    Ptr () ->                               -- object+    Ptr Mount ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkVolumeMonitorMountRemovedCallback :: VolumeMonitorMountRemovedCallbackC -> IO (FunPtr VolumeMonitorMountRemovedCallbackC)++volumeMonitorMountRemovedClosure :: VolumeMonitorMountRemovedCallback -> IO Closure+volumeMonitorMountRemovedClosure cb = newCClosure =<< mkVolumeMonitorMountRemovedCallback wrapped+    where wrapped = volumeMonitorMountRemovedCallbackWrapper cb++volumeMonitorMountRemovedCallbackWrapper ::+    VolumeMonitorMountRemovedCallback ->+    Ptr () ->+    Ptr Mount ->+    Ptr () ->+    IO ()+volumeMonitorMountRemovedCallbackWrapper _cb _ mount _ = do+    mount' <- (newObject Mount) mount+    _cb  mount'++onVolumeMonitorMountRemoved :: (GObject a, MonadIO m) => a -> VolumeMonitorMountRemovedCallback -> m SignalHandlerId+onVolumeMonitorMountRemoved obj cb = liftIO $ connectVolumeMonitorMountRemoved obj cb SignalConnectBefore+afterVolumeMonitorMountRemoved :: (GObject a, MonadIO m) => a -> VolumeMonitorMountRemovedCallback -> m SignalHandlerId+afterVolumeMonitorMountRemoved obj cb = connectVolumeMonitorMountRemoved obj cb SignalConnectAfter++connectVolumeMonitorMountRemoved :: (GObject a, MonadIO m) =>+                                    a -> VolumeMonitorMountRemovedCallback -> SignalConnectMode -> m SignalHandlerId+connectVolumeMonitorMountRemoved obj cb after = liftIO $ do+    cb' <- mkVolumeMonitorMountRemovedCallback (volumeMonitorMountRemovedCallbackWrapper cb)+    connectSignalFunPtr obj "mount-removed" cb' after++-- signal VolumeMonitor::volume-added+type VolumeMonitorVolumeAddedCallback =+    Volume ->+    IO ()++noVolumeMonitorVolumeAddedCallback :: Maybe VolumeMonitorVolumeAddedCallback+noVolumeMonitorVolumeAddedCallback = Nothing++type VolumeMonitorVolumeAddedCallbackC =+    Ptr () ->                               -- object+    Ptr Volume ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkVolumeMonitorVolumeAddedCallback :: VolumeMonitorVolumeAddedCallbackC -> IO (FunPtr VolumeMonitorVolumeAddedCallbackC)++volumeMonitorVolumeAddedClosure :: VolumeMonitorVolumeAddedCallback -> IO Closure+volumeMonitorVolumeAddedClosure cb = newCClosure =<< mkVolumeMonitorVolumeAddedCallback wrapped+    where wrapped = volumeMonitorVolumeAddedCallbackWrapper cb++volumeMonitorVolumeAddedCallbackWrapper ::+    VolumeMonitorVolumeAddedCallback ->+    Ptr () ->+    Ptr Volume ->+    Ptr () ->+    IO ()+volumeMonitorVolumeAddedCallbackWrapper _cb _ volume _ = do+    volume' <- (newObject Volume) volume+    _cb  volume'++onVolumeMonitorVolumeAdded :: (GObject a, MonadIO m) => a -> VolumeMonitorVolumeAddedCallback -> m SignalHandlerId+onVolumeMonitorVolumeAdded obj cb = liftIO $ connectVolumeMonitorVolumeAdded obj cb SignalConnectBefore+afterVolumeMonitorVolumeAdded :: (GObject a, MonadIO m) => a -> VolumeMonitorVolumeAddedCallback -> m SignalHandlerId+afterVolumeMonitorVolumeAdded obj cb = connectVolumeMonitorVolumeAdded obj cb SignalConnectAfter++connectVolumeMonitorVolumeAdded :: (GObject a, MonadIO m) =>+                                   a -> VolumeMonitorVolumeAddedCallback -> SignalConnectMode -> m SignalHandlerId+connectVolumeMonitorVolumeAdded obj cb after = liftIO $ do+    cb' <- mkVolumeMonitorVolumeAddedCallback (volumeMonitorVolumeAddedCallbackWrapper cb)+    connectSignalFunPtr obj "volume-added" cb' after++-- signal VolumeMonitor::volume-changed+type VolumeMonitorVolumeChangedCallback =+    Volume ->+    IO ()++noVolumeMonitorVolumeChangedCallback :: Maybe VolumeMonitorVolumeChangedCallback+noVolumeMonitorVolumeChangedCallback = Nothing++type VolumeMonitorVolumeChangedCallbackC =+    Ptr () ->                               -- object+    Ptr Volume ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkVolumeMonitorVolumeChangedCallback :: VolumeMonitorVolumeChangedCallbackC -> IO (FunPtr VolumeMonitorVolumeChangedCallbackC)++volumeMonitorVolumeChangedClosure :: VolumeMonitorVolumeChangedCallback -> IO Closure+volumeMonitorVolumeChangedClosure cb = newCClosure =<< mkVolumeMonitorVolumeChangedCallback wrapped+    where wrapped = volumeMonitorVolumeChangedCallbackWrapper cb++volumeMonitorVolumeChangedCallbackWrapper ::+    VolumeMonitorVolumeChangedCallback ->+    Ptr () ->+    Ptr Volume ->+    Ptr () ->+    IO ()+volumeMonitorVolumeChangedCallbackWrapper _cb _ volume _ = do+    volume' <- (newObject Volume) volume+    _cb  volume'++onVolumeMonitorVolumeChanged :: (GObject a, MonadIO m) => a -> VolumeMonitorVolumeChangedCallback -> m SignalHandlerId+onVolumeMonitorVolumeChanged obj cb = liftIO $ connectVolumeMonitorVolumeChanged obj cb SignalConnectBefore+afterVolumeMonitorVolumeChanged :: (GObject a, MonadIO m) => a -> VolumeMonitorVolumeChangedCallback -> m SignalHandlerId+afterVolumeMonitorVolumeChanged obj cb = connectVolumeMonitorVolumeChanged obj cb SignalConnectAfter++connectVolumeMonitorVolumeChanged :: (GObject a, MonadIO m) =>+                                     a -> VolumeMonitorVolumeChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectVolumeMonitorVolumeChanged obj cb after = liftIO $ do+    cb' <- mkVolumeMonitorVolumeChangedCallback (volumeMonitorVolumeChangedCallbackWrapper cb)+    connectSignalFunPtr obj "volume-changed" cb' after++-- signal VolumeMonitor::volume-removed+type VolumeMonitorVolumeRemovedCallback =+    Volume ->+    IO ()++noVolumeMonitorVolumeRemovedCallback :: Maybe VolumeMonitorVolumeRemovedCallback+noVolumeMonitorVolumeRemovedCallback = Nothing++type VolumeMonitorVolumeRemovedCallbackC =+    Ptr () ->                               -- object+    Ptr Volume ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkVolumeMonitorVolumeRemovedCallback :: VolumeMonitorVolumeRemovedCallbackC -> IO (FunPtr VolumeMonitorVolumeRemovedCallbackC)++volumeMonitorVolumeRemovedClosure :: VolumeMonitorVolumeRemovedCallback -> IO Closure+volumeMonitorVolumeRemovedClosure cb = newCClosure =<< mkVolumeMonitorVolumeRemovedCallback wrapped+    where wrapped = volumeMonitorVolumeRemovedCallbackWrapper cb++volumeMonitorVolumeRemovedCallbackWrapper ::+    VolumeMonitorVolumeRemovedCallback ->+    Ptr () ->+    Ptr Volume ->+    Ptr () ->+    IO ()+volumeMonitorVolumeRemovedCallbackWrapper _cb _ volume _ = do+    volume' <- (newObject Volume) volume+    _cb  volume'++onVolumeMonitorVolumeRemoved :: (GObject a, MonadIO m) => a -> VolumeMonitorVolumeRemovedCallback -> m SignalHandlerId+onVolumeMonitorVolumeRemoved obj cb = liftIO $ connectVolumeMonitorVolumeRemoved obj cb SignalConnectBefore+afterVolumeMonitorVolumeRemoved :: (GObject a, MonadIO m) => a -> VolumeMonitorVolumeRemovedCallback -> m SignalHandlerId+afterVolumeMonitorVolumeRemoved obj cb = connectVolumeMonitorVolumeRemoved obj cb SignalConnectAfter++connectVolumeMonitorVolumeRemoved :: (GObject a, MonadIO m) =>+                                     a -> VolumeMonitorVolumeRemovedCallback -> SignalConnectMode -> m SignalHandlerId+connectVolumeMonitorVolumeRemoved obj cb after = liftIO $ do+    cb' <- mkVolumeMonitorVolumeRemovedCallback (volumeMonitorVolumeRemovedCallbackWrapper cb)+    connectSignalFunPtr obj "volume-removed" cb' after++type instance AttributeList VolumeMonitor = VolumeMonitorAttributeList+type VolumeMonitorAttributeList = ('[ ] :: [(Symbol, *)])++data VolumeMonitorDriveChangedSignalInfo+instance SignalInfo VolumeMonitorDriveChangedSignalInfo where+    type HaskellCallbackType VolumeMonitorDriveChangedSignalInfo = VolumeMonitorDriveChangedCallback+    connectSignal _ = connectVolumeMonitorDriveChanged++data VolumeMonitorDriveConnectedSignalInfo+instance SignalInfo VolumeMonitorDriveConnectedSignalInfo where+    type HaskellCallbackType VolumeMonitorDriveConnectedSignalInfo = VolumeMonitorDriveConnectedCallback+    connectSignal _ = connectVolumeMonitorDriveConnected++data VolumeMonitorDriveDisconnectedSignalInfo+instance SignalInfo VolumeMonitorDriveDisconnectedSignalInfo where+    type HaskellCallbackType VolumeMonitorDriveDisconnectedSignalInfo = VolumeMonitorDriveDisconnectedCallback+    connectSignal _ = connectVolumeMonitorDriveDisconnected++data VolumeMonitorDriveEjectButtonSignalInfo+instance SignalInfo VolumeMonitorDriveEjectButtonSignalInfo where+    type HaskellCallbackType VolumeMonitorDriveEjectButtonSignalInfo = VolumeMonitorDriveEjectButtonCallback+    connectSignal _ = connectVolumeMonitorDriveEjectButton++data VolumeMonitorDriveStopButtonSignalInfo+instance SignalInfo VolumeMonitorDriveStopButtonSignalInfo where+    type HaskellCallbackType VolumeMonitorDriveStopButtonSignalInfo = VolumeMonitorDriveStopButtonCallback+    connectSignal _ = connectVolumeMonitorDriveStopButton++data VolumeMonitorMountAddedSignalInfo+instance SignalInfo VolumeMonitorMountAddedSignalInfo where+    type HaskellCallbackType VolumeMonitorMountAddedSignalInfo = VolumeMonitorMountAddedCallback+    connectSignal _ = connectVolumeMonitorMountAdded++data VolumeMonitorMountChangedSignalInfo+instance SignalInfo VolumeMonitorMountChangedSignalInfo where+    type HaskellCallbackType VolumeMonitorMountChangedSignalInfo = VolumeMonitorMountChangedCallback+    connectSignal _ = connectVolumeMonitorMountChanged++data VolumeMonitorMountPreUnmountSignalInfo+instance SignalInfo VolumeMonitorMountPreUnmountSignalInfo where+    type HaskellCallbackType VolumeMonitorMountPreUnmountSignalInfo = VolumeMonitorMountPreUnmountCallback+    connectSignal _ = connectVolumeMonitorMountPreUnmount++data VolumeMonitorMountRemovedSignalInfo+instance SignalInfo VolumeMonitorMountRemovedSignalInfo where+    type HaskellCallbackType VolumeMonitorMountRemovedSignalInfo = VolumeMonitorMountRemovedCallback+    connectSignal _ = connectVolumeMonitorMountRemoved++data VolumeMonitorVolumeAddedSignalInfo+instance SignalInfo VolumeMonitorVolumeAddedSignalInfo where+    type HaskellCallbackType VolumeMonitorVolumeAddedSignalInfo = VolumeMonitorVolumeAddedCallback+    connectSignal _ = connectVolumeMonitorVolumeAdded++data VolumeMonitorVolumeChangedSignalInfo+instance SignalInfo VolumeMonitorVolumeChangedSignalInfo where+    type HaskellCallbackType VolumeMonitorVolumeChangedSignalInfo = VolumeMonitorVolumeChangedCallback+    connectSignal _ = connectVolumeMonitorVolumeChanged++data VolumeMonitorVolumeRemovedSignalInfo+instance SignalInfo VolumeMonitorVolumeRemovedSignalInfo where+    type HaskellCallbackType VolumeMonitorVolumeRemovedSignalInfo = VolumeMonitorVolumeRemovedCallback+    connectSignal _ = connectVolumeMonitorVolumeRemoved++type instance SignalList VolumeMonitor = VolumeMonitorSignalList+type VolumeMonitorSignalList = ('[ '("drive-changed", VolumeMonitorDriveChangedSignalInfo), '("drive-connected", VolumeMonitorDriveConnectedSignalInfo), '("drive-disconnected", VolumeMonitorDriveDisconnectedSignalInfo), '("drive-eject-button", VolumeMonitorDriveEjectButtonSignalInfo), '("drive-stop-button", VolumeMonitorDriveStopButtonSignalInfo), '("mount-added", VolumeMonitorMountAddedSignalInfo), '("mount-changed", VolumeMonitorMountChangedSignalInfo), '("mount-pre-unmount", VolumeMonitorMountPreUnmountSignalInfo), '("mount-removed", VolumeMonitorMountRemovedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("volume-added", VolumeMonitorVolumeAddedSignalInfo), '("volume-changed", VolumeMonitorVolumeChangedSignalInfo), '("volume-removed", VolumeMonitorVolumeRemovedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method VolumeMonitor::get_connected_drives+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "VolumeMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "VolumeMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gio" "Drive")+-- throws : False+-- Skip return : False++foreign import ccall "g_volume_monitor_get_connected_drives" g_volume_monitor_get_connected_drives :: +    Ptr VolumeMonitor ->                    -- _obj : TInterface "Gio" "VolumeMonitor"+    IO (Ptr (GList (Ptr Drive)))+++volumeMonitorGetConnectedDrives ::+    (MonadIO m, VolumeMonitorK a) =>+    a ->                                    -- _obj+    m [Drive]+volumeMonitorGetConnectedDrives _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_volume_monitor_get_connected_drives _obj'+    checkUnexpectedReturnNULL "g_volume_monitor_get_connected_drives" result+    result' <- unpackGList result+    result'' <- mapM (wrapObject Drive) result'+    g_list_free result+    touchManagedPtr _obj+    return result''++-- method VolumeMonitor::get_mount_for_uuid+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "VolumeMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "uuid", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "VolumeMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "uuid", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Mount"+-- throws : False+-- Skip return : False++foreign import ccall "g_volume_monitor_get_mount_for_uuid" g_volume_monitor_get_mount_for_uuid :: +    Ptr VolumeMonitor ->                    -- _obj : TInterface "Gio" "VolumeMonitor"+    CString ->                              -- uuid : TBasicType TUTF8+    IO (Ptr Mount)+++volumeMonitorGetMountForUuid ::+    (MonadIO m, VolumeMonitorK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- uuid+    m Mount+volumeMonitorGetMountForUuid _obj uuid = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    uuid' <- textToCString uuid+    result <- g_volume_monitor_get_mount_for_uuid _obj' uuid'+    checkUnexpectedReturnNULL "g_volume_monitor_get_mount_for_uuid" result+    result' <- (wrapObject Mount) result+    touchManagedPtr _obj+    freeMem uuid'+    return result'++-- method VolumeMonitor::get_mounts+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "VolumeMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "VolumeMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gio" "Mount")+-- throws : False+-- Skip return : False++foreign import ccall "g_volume_monitor_get_mounts" g_volume_monitor_get_mounts :: +    Ptr VolumeMonitor ->                    -- _obj : TInterface "Gio" "VolumeMonitor"+    IO (Ptr (GList (Ptr Mount)))+++volumeMonitorGetMounts ::+    (MonadIO m, VolumeMonitorK a) =>+    a ->                                    -- _obj+    m [Mount]+volumeMonitorGetMounts _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_volume_monitor_get_mounts _obj'+    checkUnexpectedReturnNULL "g_volume_monitor_get_mounts" result+    result' <- unpackGList result+    result'' <- mapM (wrapObject Mount) result'+    g_list_free result+    touchManagedPtr _obj+    return result''++-- method VolumeMonitor::get_volume_for_uuid+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "VolumeMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "uuid", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "VolumeMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "uuid", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Volume"+-- throws : False+-- Skip return : False++foreign import ccall "g_volume_monitor_get_volume_for_uuid" g_volume_monitor_get_volume_for_uuid :: +    Ptr VolumeMonitor ->                    -- _obj : TInterface "Gio" "VolumeMonitor"+    CString ->                              -- uuid : TBasicType TUTF8+    IO (Ptr Volume)+++volumeMonitorGetVolumeForUuid ::+    (MonadIO m, VolumeMonitorK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- uuid+    m Volume+volumeMonitorGetVolumeForUuid _obj uuid = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    uuid' <- textToCString uuid+    result <- g_volume_monitor_get_volume_for_uuid _obj' uuid'+    checkUnexpectedReturnNULL "g_volume_monitor_get_volume_for_uuid" result+    result' <- (wrapObject Volume) result+    touchManagedPtr _obj+    freeMem uuid'+    return result'++-- method VolumeMonitor::get_volumes+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "VolumeMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "VolumeMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gio" "Volume")+-- throws : False+-- Skip return : False++foreign import ccall "g_volume_monitor_get_volumes" g_volume_monitor_get_volumes :: +    Ptr VolumeMonitor ->                    -- _obj : TInterface "Gio" "VolumeMonitor"+    IO (Ptr (GList (Ptr Volume)))+++volumeMonitorGetVolumes ::+    (MonadIO m, VolumeMonitorK a) =>+    a ->                                    -- _obj+    m [Volume]+volumeMonitorGetVolumes _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_volume_monitor_get_volumes _obj'+    checkUnexpectedReturnNULL "g_volume_monitor_get_volumes" result+    result' <- unpackGList result+    result'' <- mapM (wrapObject Volume) result'+    g_list_free result+    touchManagedPtr _obj+    return result''++-- method VolumeMonitor::adopt_orphan_mount+-- method type : MemberFunction+-- Args : [Arg {argName = "mount", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "mount", argType = TInterface "Gio" "Mount", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Volume"+-- throws : False+-- Skip return : False++foreign import ccall "g_volume_monitor_adopt_orphan_mount" g_volume_monitor_adopt_orphan_mount :: +    Ptr Mount ->                            -- mount : TInterface "Gio" "Mount"+    IO (Ptr Volume)++{-# DEPRECATED volumeMonitorAdoptOrphanMount ["(Since version 2.20)","Instead of using this function, #GVolumeMonitor","implementations should instead create shadow mounts with the URI of","the mount they intend to adopt. See the proxy volume monitor in","gvfs for an example of this. Also see g_mount_is_shadowed(),","g_mount_shadow() and g_mount_unshadow() functions."]#-}+volumeMonitorAdoptOrphanMount ::+    (MonadIO m, MountK a) =>+    a ->                                    -- mount+    m Volume+volumeMonitorAdoptOrphanMount mount = liftIO $ do+    let mount' = unsafeManagedPtrCastPtr mount+    result <- g_volume_monitor_adopt_orphan_mount mount'+    checkUnexpectedReturnNULL "g_volume_monitor_adopt_orphan_mount" result+    result' <- (wrapObject Volume) result+    touchManagedPtr mount+    return result'++-- method VolumeMonitor::get+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gio" "VolumeMonitor"+-- throws : False+-- Skip return : False++foreign import ccall "g_volume_monitor_get" g_volume_monitor_get :: +    IO (Ptr VolumeMonitor)+++volumeMonitorGet ::+    (MonadIO m) =>+    m VolumeMonitor+volumeMonitorGet  = liftIO $ do+    result <- g_volume_monitor_get+    checkUnexpectedReturnNULL "g_volume_monitor_get" result+    result' <- (wrapObject VolumeMonitor) result+    return result'++
+ GI/Gio/Objects/VolumeMonitor.hs-boot view
@@ -0,0 +1,25 @@+module GI.Gio.Objects.VolumeMonitor where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype VolumeMonitor = VolumeMonitor (ForeignPtr VolumeMonitor)+instance GObject VolumeMonitor where+class GObject o => VolumeMonitorK o+instance (GObject o, IsDescendantOf VolumeMonitor o) => VolumeMonitorK o+data VolumeMonitorDriveChangedSignalInfo+data VolumeMonitorDriveConnectedSignalInfo+data VolumeMonitorDriveDisconnectedSignalInfo+data VolumeMonitorDriveEjectButtonSignalInfo+data VolumeMonitorDriveStopButtonSignalInfo+data VolumeMonitorMountAddedSignalInfo+data VolumeMonitorMountChangedSignalInfo+data VolumeMonitorMountPreUnmountSignalInfo+data VolumeMonitorMountRemovedSignalInfo+data VolumeMonitorVolumeAddedSignalInfo+data VolumeMonitorVolumeChangedSignalInfo+data VolumeMonitorVolumeRemovedSignalInfo
+ GI/Gio/Objects/ZlibCompressor.hs view
@@ -0,0 +1,246 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.ZlibCompressor+    ( ++-- * Exported types+    ZlibCompressor(..)                      ,+    ZlibCompressorK                         ,+    toZlibCompressor                        ,+    noZlibCompressor                        ,+++ -- * Methods+-- ** zlibCompressorGetFileInfo+    zlibCompressorGetFileInfo               ,+++-- ** zlibCompressorNew+    zlibCompressorNew                       ,+++-- ** zlibCompressorSetFileInfo+    zlibCompressorSetFileInfo               ,+++++ -- * Properties+-- ** FileInfo+    ZlibCompressorFileInfoPropertyInfo      ,+    constructZlibCompressorFileInfo         ,+    getZlibCompressorFileInfo               ,+    setZlibCompressorFileInfo               ,+++-- ** Format+    ZlibCompressorFormatPropertyInfo        ,+    constructZlibCompressorFormat           ,+    getZlibCompressorFormat                 ,+++-- ** Level+    ZlibCompressorLevelPropertyInfo         ,+    constructZlibCompressorLevel            ,+    getZlibCompressorLevel                  ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype ZlibCompressor = ZlibCompressor (ForeignPtr ZlibCompressor)+foreign import ccall "g_zlib_compressor_get_type"+    c_g_zlib_compressor_get_type :: IO GType++type instance ParentTypes ZlibCompressor = ZlibCompressorParentTypes+type ZlibCompressorParentTypes = '[GObject.Object, Converter]++instance GObject ZlibCompressor where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_zlib_compressor_get_type+    ++class GObject o => ZlibCompressorK o+instance (GObject o, IsDescendantOf ZlibCompressor o) => ZlibCompressorK o++toZlibCompressor :: ZlibCompressorK o => o -> IO ZlibCompressor+toZlibCompressor = unsafeCastTo ZlibCompressor++noZlibCompressor :: Maybe ZlibCompressor+noZlibCompressor = Nothing++-- VVV Prop "file-info"+   -- Type: TInterface "Gio" "FileInfo"+   -- Flags: [PropertyReadable,PropertyWritable]++getZlibCompressorFileInfo :: (MonadIO m, ZlibCompressorK o) => o -> m FileInfo+getZlibCompressorFileInfo obj = liftIO $ getObjectPropertyObject obj "file-info" FileInfo++setZlibCompressorFileInfo :: (MonadIO m, ZlibCompressorK o, FileInfoK a) => o -> a -> m ()+setZlibCompressorFileInfo obj val = liftIO $ setObjectPropertyObject obj "file-info" val++constructZlibCompressorFileInfo :: (FileInfoK a) => a -> IO ([Char], GValue)+constructZlibCompressorFileInfo val = constructObjectPropertyObject "file-info" val++data ZlibCompressorFileInfoPropertyInfo+instance AttrInfo ZlibCompressorFileInfoPropertyInfo where+    type AttrAllowedOps ZlibCompressorFileInfoPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ZlibCompressorFileInfoPropertyInfo = FileInfoK+    type AttrBaseTypeConstraint ZlibCompressorFileInfoPropertyInfo = ZlibCompressorK+    type AttrGetType ZlibCompressorFileInfoPropertyInfo = FileInfo+    type AttrLabel ZlibCompressorFileInfoPropertyInfo = "ZlibCompressor::file-info"+    attrGet _ = getZlibCompressorFileInfo+    attrSet _ = setZlibCompressorFileInfo+    attrConstruct _ = constructZlibCompressorFileInfo++-- VVV Prop "format"+   -- Type: TInterface "Gio" "ZlibCompressorFormat"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getZlibCompressorFormat :: (MonadIO m, ZlibCompressorK o) => o -> m ZlibCompressorFormat+getZlibCompressorFormat obj = liftIO $ getObjectPropertyEnum obj "format"++constructZlibCompressorFormat :: ZlibCompressorFormat -> IO ([Char], GValue)+constructZlibCompressorFormat val = constructObjectPropertyEnum "format" val++data ZlibCompressorFormatPropertyInfo+instance AttrInfo ZlibCompressorFormatPropertyInfo where+    type AttrAllowedOps ZlibCompressorFormatPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ZlibCompressorFormatPropertyInfo = (~) ZlibCompressorFormat+    type AttrBaseTypeConstraint ZlibCompressorFormatPropertyInfo = ZlibCompressorK+    type AttrGetType ZlibCompressorFormatPropertyInfo = ZlibCompressorFormat+    type AttrLabel ZlibCompressorFormatPropertyInfo = "ZlibCompressor::format"+    attrGet _ = getZlibCompressorFormat+    attrSet _ = undefined+    attrConstruct _ = constructZlibCompressorFormat++-- VVV Prop "level"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getZlibCompressorLevel :: (MonadIO m, ZlibCompressorK o) => o -> m Int32+getZlibCompressorLevel obj = liftIO $ getObjectPropertyCInt obj "level"++constructZlibCompressorLevel :: Int32 -> IO ([Char], GValue)+constructZlibCompressorLevel val = constructObjectPropertyCInt "level" val++data ZlibCompressorLevelPropertyInfo+instance AttrInfo ZlibCompressorLevelPropertyInfo where+    type AttrAllowedOps ZlibCompressorLevelPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ZlibCompressorLevelPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint ZlibCompressorLevelPropertyInfo = ZlibCompressorK+    type AttrGetType ZlibCompressorLevelPropertyInfo = Int32+    type AttrLabel ZlibCompressorLevelPropertyInfo = "ZlibCompressor::level"+    attrGet _ = getZlibCompressorLevel+    attrSet _ = undefined+    attrConstruct _ = constructZlibCompressorLevel++type instance AttributeList ZlibCompressor = ZlibCompressorAttributeList+type ZlibCompressorAttributeList = ('[ '("file-info", ZlibCompressorFileInfoPropertyInfo), '("format", ZlibCompressorFormatPropertyInfo), '("level", ZlibCompressorLevelPropertyInfo)] :: [(Symbol, *)])++type instance SignalList ZlibCompressor = ZlibCompressorSignalList+type ZlibCompressorSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method ZlibCompressor::new+-- method type : Constructor+-- Args : [Arg {argName = "format", argType = TInterface "Gio" "ZlibCompressorFormat", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "level", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "format", argType = TInterface "Gio" "ZlibCompressorFormat", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "level", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "ZlibCompressor"+-- throws : False+-- Skip return : False++foreign import ccall "g_zlib_compressor_new" g_zlib_compressor_new :: +    CUInt ->                                -- format : TInterface "Gio" "ZlibCompressorFormat"+    Int32 ->                                -- level : TBasicType TInt32+    IO (Ptr ZlibCompressor)+++zlibCompressorNew ::+    (MonadIO m) =>+    ZlibCompressorFormat ->                 -- format+    Int32 ->                                -- level+    m ZlibCompressor+zlibCompressorNew format level = liftIO $ do+    let format' = (fromIntegral . fromEnum) format+    result <- g_zlib_compressor_new format' level+    checkUnexpectedReturnNULL "g_zlib_compressor_new" result+    result' <- (wrapObject ZlibCompressor) result+    return result'++-- method ZlibCompressor::get_file_info+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ZlibCompressor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ZlibCompressor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileInfo"+-- throws : False+-- Skip return : False++foreign import ccall "g_zlib_compressor_get_file_info" g_zlib_compressor_get_file_info :: +    Ptr ZlibCompressor ->                   -- _obj : TInterface "Gio" "ZlibCompressor"+    IO (Ptr FileInfo)+++zlibCompressorGetFileInfo ::+    (MonadIO m, ZlibCompressorK a) =>+    a ->                                    -- _obj+    m FileInfo+zlibCompressorGetFileInfo _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_zlib_compressor_get_file_info _obj'+    checkUnexpectedReturnNULL "g_zlib_compressor_get_file_info" result+    result' <- (newObject FileInfo) result+    touchManagedPtr _obj+    return result'++-- method ZlibCompressor::set_file_info+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ZlibCompressor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "file_info", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ZlibCompressor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "file_info", argType = TInterface "Gio" "FileInfo", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_zlib_compressor_set_file_info" g_zlib_compressor_set_file_info :: +    Ptr ZlibCompressor ->                   -- _obj : TInterface "Gio" "ZlibCompressor"+    Ptr FileInfo ->                         -- file_info : TInterface "Gio" "FileInfo"+    IO ()+++zlibCompressorSetFileInfo ::+    (MonadIO m, ZlibCompressorK a, FileInfoK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- file_info+    m ()+zlibCompressorSetFileInfo _obj file_info = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeFile_info <- case file_info of+        Nothing -> return nullPtr+        Just jFile_info -> do+            let jFile_info' = unsafeManagedPtrCastPtr jFile_info+            return jFile_info'+    g_zlib_compressor_set_file_info _obj' maybeFile_info+    touchManagedPtr _obj+    whenJust file_info touchManagedPtr+    return ()++
+ GI/Gio/Objects/ZlibCompressor.hs-boot view
@@ -0,0 +1,16 @@+module GI.Gio.Objects.ZlibCompressor where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype ZlibCompressor = ZlibCompressor (ForeignPtr ZlibCompressor)+instance GObject ZlibCompressor where+class GObject o => ZlibCompressorK o+instance (GObject o, IsDescendantOf ZlibCompressor o) => ZlibCompressorK o+data ZlibCompressorFileInfoPropertyInfo+data ZlibCompressorFormatPropertyInfo+data ZlibCompressorLevelPropertyInfo
+ GI/Gio/Objects/ZlibDecompressor.hs view
@@ -0,0 +1,173 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Objects.ZlibDecompressor+    ( ++-- * Exported types+    ZlibDecompressor(..)                    ,+    ZlibDecompressorK                       ,+    toZlibDecompressor                      ,+    noZlibDecompressor                      ,+++ -- * Methods+-- ** zlibDecompressorGetFileInfo+    zlibDecompressorGetFileInfo             ,+++-- ** zlibDecompressorNew+    zlibDecompressorNew                     ,+++++ -- * Properties+-- ** FileInfo+    ZlibDecompressorFileInfoPropertyInfo    ,+    getZlibDecompressorFileInfo             ,+++-- ** Format+    ZlibDecompressorFormatPropertyInfo      ,+    constructZlibDecompressorFormat         ,+    getZlibDecompressorFormat               ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GObject as GObject++newtype ZlibDecompressor = ZlibDecompressor (ForeignPtr ZlibDecompressor)+foreign import ccall "g_zlib_decompressor_get_type"+    c_g_zlib_decompressor_get_type :: IO GType++type instance ParentTypes ZlibDecompressor = ZlibDecompressorParentTypes+type ZlibDecompressorParentTypes = '[GObject.Object, Converter]++instance GObject ZlibDecompressor where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_g_zlib_decompressor_get_type+    ++class GObject o => ZlibDecompressorK o+instance (GObject o, IsDescendantOf ZlibDecompressor o) => ZlibDecompressorK o++toZlibDecompressor :: ZlibDecompressorK o => o -> IO ZlibDecompressor+toZlibDecompressor = unsafeCastTo ZlibDecompressor++noZlibDecompressor :: Maybe ZlibDecompressor+noZlibDecompressor = Nothing++-- VVV Prop "file-info"+   -- Type: TInterface "Gio" "FileInfo"+   -- Flags: [PropertyReadable]++getZlibDecompressorFileInfo :: (MonadIO m, ZlibDecompressorK o) => o -> m FileInfo+getZlibDecompressorFileInfo obj = liftIO $ getObjectPropertyObject obj "file-info" FileInfo++data ZlibDecompressorFileInfoPropertyInfo+instance AttrInfo ZlibDecompressorFileInfoPropertyInfo where+    type AttrAllowedOps ZlibDecompressorFileInfoPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint ZlibDecompressorFileInfoPropertyInfo = (~) ()+    type AttrBaseTypeConstraint ZlibDecompressorFileInfoPropertyInfo = ZlibDecompressorK+    type AttrGetType ZlibDecompressorFileInfoPropertyInfo = FileInfo+    type AttrLabel ZlibDecompressorFileInfoPropertyInfo = "ZlibDecompressor::file-info"+    attrGet _ = getZlibDecompressorFileInfo+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "format"+   -- Type: TInterface "Gio" "ZlibCompressorFormat"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getZlibDecompressorFormat :: (MonadIO m, ZlibDecompressorK o) => o -> m ZlibCompressorFormat+getZlibDecompressorFormat obj = liftIO $ getObjectPropertyEnum obj "format"++constructZlibDecompressorFormat :: ZlibCompressorFormat -> IO ([Char], GValue)+constructZlibDecompressorFormat val = constructObjectPropertyEnum "format" val++data ZlibDecompressorFormatPropertyInfo+instance AttrInfo ZlibDecompressorFormatPropertyInfo where+    type AttrAllowedOps ZlibDecompressorFormatPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ZlibDecompressorFormatPropertyInfo = (~) ZlibCompressorFormat+    type AttrBaseTypeConstraint ZlibDecompressorFormatPropertyInfo = ZlibDecompressorK+    type AttrGetType ZlibDecompressorFormatPropertyInfo = ZlibCompressorFormat+    type AttrLabel ZlibDecompressorFormatPropertyInfo = "ZlibDecompressor::format"+    attrGet _ = getZlibDecompressorFormat+    attrSet _ = undefined+    attrConstruct _ = constructZlibDecompressorFormat++type instance AttributeList ZlibDecompressor = ZlibDecompressorAttributeList+type ZlibDecompressorAttributeList = ('[ '("file-info", ZlibDecompressorFileInfoPropertyInfo), '("format", ZlibDecompressorFormatPropertyInfo)] :: [(Symbol, *)])++type instance SignalList ZlibDecompressor = ZlibDecompressorSignalList+type ZlibDecompressorSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method ZlibDecompressor::new+-- method type : Constructor+-- Args : [Arg {argName = "format", argType = TInterface "Gio" "ZlibCompressorFormat", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "format", argType = TInterface "Gio" "ZlibCompressorFormat", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "ZlibDecompressor"+-- throws : False+-- Skip return : False++foreign import ccall "g_zlib_decompressor_new" g_zlib_decompressor_new :: +    CUInt ->                                -- format : TInterface "Gio" "ZlibCompressorFormat"+    IO (Ptr ZlibDecompressor)+++zlibDecompressorNew ::+    (MonadIO m) =>+    ZlibCompressorFormat ->                 -- format+    m ZlibDecompressor+zlibDecompressorNew format = liftIO $ do+    let format' = (fromIntegral . fromEnum) format+    result <- g_zlib_decompressor_new format'+    checkUnexpectedReturnNULL "g_zlib_decompressor_new" result+    result' <- (wrapObject ZlibDecompressor) result+    return result'++-- method ZlibDecompressor::get_file_info+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "ZlibDecompressor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "ZlibDecompressor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileInfo"+-- throws : False+-- Skip return : False++foreign import ccall "g_zlib_decompressor_get_file_info" g_zlib_decompressor_get_file_info :: +    Ptr ZlibDecompressor ->                 -- _obj : TInterface "Gio" "ZlibDecompressor"+    IO (Ptr FileInfo)+++zlibDecompressorGetFileInfo ::+    (MonadIO m, ZlibDecompressorK a) =>+    a ->                                    -- _obj+    m FileInfo+zlibDecompressorGetFileInfo _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- g_zlib_decompressor_get_file_info _obj'+    checkUnexpectedReturnNULL "g_zlib_decompressor_get_file_info" result+    result' <- (newObject FileInfo) result+    touchManagedPtr _obj+    return result'++
+ GI/Gio/Objects/ZlibDecompressor.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gio.Objects.ZlibDecompressor where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype ZlibDecompressor = ZlibDecompressor (ForeignPtr ZlibDecompressor)+instance GObject ZlibDecompressor where+class GObject o => ZlibDecompressorK o+instance (GObject o, IsDescendantOf ZlibDecompressor o) => ZlibDecompressorK o+data ZlibDecompressorFileInfoPropertyInfo+data ZlibDecompressorFormatPropertyInfo
+ GI/Gio/Structs.hs view
@@ -0,0 +1,88 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Structs+    (     module GI.Gio.Structs.ActionEntry       ,+    module GI.Gio.Structs.DBusAnnotationInfo,+    module GI.Gio.Structs.DBusArgInfo       ,+    module GI.Gio.Structs.DBusErrorEntry    ,+    module GI.Gio.Structs.DBusInterfaceInfo ,+    module GI.Gio.Structs.DBusInterfaceVTable,+    module GI.Gio.Structs.DBusMethodInfo    ,+    module GI.Gio.Structs.DBusNodeInfo      ,+    module GI.Gio.Structs.DBusPropertyInfo  ,+    module GI.Gio.Structs.DBusSignalInfo    ,+    module GI.Gio.Structs.DBusSubtreeVTable ,+    module GI.Gio.Structs.FileAttributeInfo ,+    module GI.Gio.Structs.FileAttributeInfoList,+    module GI.Gio.Structs.FileAttributeMatcher,+    module GI.Gio.Structs.IOExtension       ,+    module GI.Gio.Structs.IOExtensionPoint  ,+    module GI.Gio.Structs.IOModuleScope     ,+    module GI.Gio.Structs.IOSchedulerJob    ,+    module GI.Gio.Structs.IOStreamAdapter   ,+    module GI.Gio.Structs.InputVector       ,+    module GI.Gio.Structs.NativeSocketAddress,+    module GI.Gio.Structs.OutputMessage     ,+    module GI.Gio.Structs.OutputVector      ,+    module GI.Gio.Structs.Resource          ,+    module GI.Gio.Structs.SettingsBackend   ,+    module GI.Gio.Structs.SettingsSchema    ,+    module GI.Gio.Structs.SettingsSchemaKey ,+    module GI.Gio.Structs.SettingsSchemaSource,+    module GI.Gio.Structs.SrvTarget         ,+    module GI.Gio.Structs.StaticResource    ,+    module GI.Gio.Structs.UnixMountEntry    ,+    module GI.Gio.Structs.UnixMountPoint    ,+++    ) where++import GI.Gio.Structs.ActionEntry+import GI.Gio.Structs.DBusAnnotationInfo+import GI.Gio.Structs.DBusArgInfo+import GI.Gio.Structs.DBusErrorEntry+import GI.Gio.Structs.DBusInterfaceInfo+import GI.Gio.Structs.DBusInterfaceVTable+import GI.Gio.Structs.DBusMethodInfo+import GI.Gio.Structs.DBusNodeInfo+import GI.Gio.Structs.DBusPropertyInfo+import GI.Gio.Structs.DBusSignalInfo+import GI.Gio.Structs.DBusSubtreeVTable+import GI.Gio.Structs.FileAttributeInfo+import GI.Gio.Structs.FileAttributeInfoList+import GI.Gio.Structs.FileAttributeMatcher+import GI.Gio.Structs.IOExtension+import GI.Gio.Structs.IOExtensionPoint+import GI.Gio.Structs.IOModuleScope+import GI.Gio.Structs.IOSchedulerJob+import GI.Gio.Structs.IOStreamAdapter+import GI.Gio.Structs.InputVector+import GI.Gio.Structs.NativeSocketAddress+import GI.Gio.Structs.OutputMessage+import GI.Gio.Structs.OutputVector+import GI.Gio.Structs.Resource+import GI.Gio.Structs.SettingsBackend+import GI.Gio.Structs.SettingsSchema+import GI.Gio.Structs.SettingsSchemaKey+import GI.Gio.Structs.SettingsSchemaSource+import GI.Gio.Structs.SrvTarget+import GI.Gio.Structs.StaticResource+import GI.Gio.Structs.UnixMountEntry+import GI.Gio.Structs.UnixMountPoint++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks++
+ GI/Gio/Structs/ActionEntry.hs view
@@ -0,0 +1,80 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++This struct defines a single action.  It is for use with+g_action_map_add_action_entries().++The order of the items in the structure are intended to reflect+frequency of use.  It is permissible to use an incomplete initialiser+in order to leave some of the later values as %NULL.  All values+after @name are optional.  Additional optional fields may be added in+the future.++See g_action_map_add_action_entries() for an example.+-}++module GI.Gio.Structs.ActionEntry+    ( ++-- * Exported types+    ActionEntry(..)                         ,+    noActionEntry                           ,+++ -- * Properties+-- ** Name+    actionEntryReadName                     ,+++-- ** ParameterType+    actionEntryReadParameterType            ,+++-- ** State+    actionEntryReadState                    ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks++newtype ActionEntry = ActionEntry (ForeignPtr ActionEntry)+noActionEntry :: Maybe ActionEntry+noActionEntry = Nothing++actionEntryReadName :: ActionEntry -> IO T.Text+actionEntryReadName s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CString+    val' <- cstringToText val+    return val'++-- XXX Skipped getter for "ActionEntry:activate" :: Not implemented: "Wrapping foreign callbacks is not supported yet"++actionEntryReadParameterType :: ActionEntry -> IO T.Text+actionEntryReadParameterType s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO CString+    val' <- cstringToText val+    return val'++actionEntryReadState :: ActionEntry -> IO T.Text+actionEntryReadState s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 24) :: IO CString+    val' <- cstringToText val+    return val'++-- XXX Skipped getter for "ActionEntry:change_state" :: Not implemented: "Wrapping foreign callbacks is not supported yet"++
+ GI/Gio/Structs/ActionEntry.hs-boot view
@@ -0,0 +1,10 @@+module GI.Gio.Structs.ActionEntry where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype ActionEntry = ActionEntry (ForeignPtr ActionEntry)
+ GI/Gio/Structs/DBusAnnotationInfo.hs view
@@ -0,0 +1,144 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Information about an annotation.+-}++module GI.Gio.Structs.DBusAnnotationInfo+    ( ++-- * Exported types+    DBusAnnotationInfo(..)                  ,+    noDBusAnnotationInfo                    ,+++ -- * Methods+-- ** dBusAnnotationInfoRef+    dBusAnnotationInfoRef                   ,+++-- ** dBusAnnotationInfoUnref+    dBusAnnotationInfoUnref                 ,+++++ -- * Properties+-- ** Annotations+    dBusAnnotationInfoReadAnnotations       ,+++-- ** Key+    dBusAnnotationInfoReadKey               ,+++-- ** RefCount+    dBusAnnotationInfoReadRefCount          ,+++-- ** Value+    dBusAnnotationInfoReadValue             ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks++newtype DBusAnnotationInfo = DBusAnnotationInfo (ForeignPtr DBusAnnotationInfo)+foreign import ccall "g_dbus_annotation_info_get_type" c_g_dbus_annotation_info_get_type :: +    IO GType++instance BoxedObject DBusAnnotationInfo where+    boxedType _ = c_g_dbus_annotation_info_get_type++noDBusAnnotationInfo :: Maybe DBusAnnotationInfo+noDBusAnnotationInfo = Nothing++dBusAnnotationInfoReadRefCount :: DBusAnnotationInfo -> IO Int32+dBusAnnotationInfoReadRefCount s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO Int32+    return val++dBusAnnotationInfoReadKey :: DBusAnnotationInfo -> IO T.Text+dBusAnnotationInfoReadKey s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CString+    val' <- cstringToText val+    return val'++dBusAnnotationInfoReadValue :: DBusAnnotationInfo -> IO T.Text+dBusAnnotationInfoReadValue s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO CString+    val' <- cstringToText val+    return val'++dBusAnnotationInfoReadAnnotations :: DBusAnnotationInfo -> IO [DBusAnnotationInfo]+dBusAnnotationInfoReadAnnotations s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 24) :: IO (Ptr (Ptr DBusAnnotationInfo))+    val' <- unpackZeroTerminatedPtrArray val+    val'' <- mapM (newBoxed DBusAnnotationInfo) val'+    return val''++-- method DBusAnnotationInfo::ref+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusAnnotationInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusAnnotationInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusAnnotationInfo"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_annotation_info_ref" g_dbus_annotation_info_ref :: +    Ptr DBusAnnotationInfo ->               -- _obj : TInterface "Gio" "DBusAnnotationInfo"+    IO (Ptr DBusAnnotationInfo)+++dBusAnnotationInfoRef ::+    (MonadIO m) =>+    DBusAnnotationInfo ->                   -- _obj+    m DBusAnnotationInfo+dBusAnnotationInfoRef _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_dbus_annotation_info_ref _obj'+    checkUnexpectedReturnNULL "g_dbus_annotation_info_ref" result+    result' <- (wrapBoxed DBusAnnotationInfo) result+    touchManagedPtr _obj+    return result'++-- method DBusAnnotationInfo::unref+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusAnnotationInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusAnnotationInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_annotation_info_unref" g_dbus_annotation_info_unref :: +    Ptr DBusAnnotationInfo ->               -- _obj : TInterface "Gio" "DBusAnnotationInfo"+    IO ()+++dBusAnnotationInfoUnref ::+    (MonadIO m) =>+    DBusAnnotationInfo ->                   -- _obj+    m ()+dBusAnnotationInfoUnref _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    g_dbus_annotation_info_unref _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Structs/DBusAnnotationInfo.hs-boot view
@@ -0,0 +1,11 @@+module GI.Gio.Structs.DBusAnnotationInfo where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype DBusAnnotationInfo = DBusAnnotationInfo (ForeignPtr DBusAnnotationInfo)+instance BoxedObject DBusAnnotationInfo where
+ GI/Gio/Structs/DBusArgInfo.hs view
@@ -0,0 +1,144 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Information about an argument for a method or a signal.+-}++module GI.Gio.Structs.DBusArgInfo+    ( ++-- * Exported types+    DBusArgInfo(..)                         ,+    noDBusArgInfo                           ,+++ -- * Methods+-- ** dBusArgInfoRef+    dBusArgInfoRef                          ,+++-- ** dBusArgInfoUnref+    dBusArgInfoUnref                        ,+++++ -- * Properties+-- ** Annotations+    dBusArgInfoReadAnnotations              ,+++-- ** Name+    dBusArgInfoReadName                     ,+++-- ** RefCount+    dBusArgInfoReadRefCount                 ,+++-- ** Signature+    dBusArgInfoReadSignature                ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks++newtype DBusArgInfo = DBusArgInfo (ForeignPtr DBusArgInfo)+foreign import ccall "g_dbus_arg_info_get_type" c_g_dbus_arg_info_get_type :: +    IO GType++instance BoxedObject DBusArgInfo where+    boxedType _ = c_g_dbus_arg_info_get_type++noDBusArgInfo :: Maybe DBusArgInfo+noDBusArgInfo = Nothing++dBusArgInfoReadRefCount :: DBusArgInfo -> IO Int32+dBusArgInfoReadRefCount s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO Int32+    return val++dBusArgInfoReadName :: DBusArgInfo -> IO T.Text+dBusArgInfoReadName s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CString+    val' <- cstringToText val+    return val'++dBusArgInfoReadSignature :: DBusArgInfo -> IO T.Text+dBusArgInfoReadSignature s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO CString+    val' <- cstringToText val+    return val'++dBusArgInfoReadAnnotations :: DBusArgInfo -> IO [DBusAnnotationInfo]+dBusArgInfoReadAnnotations s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 24) :: IO (Ptr (Ptr DBusAnnotationInfo))+    val' <- unpackZeroTerminatedPtrArray val+    val'' <- mapM (newBoxed DBusAnnotationInfo) val'+    return val''++-- method DBusArgInfo::ref+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusArgInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusArgInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusArgInfo"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_arg_info_ref" g_dbus_arg_info_ref :: +    Ptr DBusArgInfo ->                      -- _obj : TInterface "Gio" "DBusArgInfo"+    IO (Ptr DBusArgInfo)+++dBusArgInfoRef ::+    (MonadIO m) =>+    DBusArgInfo ->                          -- _obj+    m DBusArgInfo+dBusArgInfoRef _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_dbus_arg_info_ref _obj'+    checkUnexpectedReturnNULL "g_dbus_arg_info_ref" result+    result' <- (wrapBoxed DBusArgInfo) result+    touchManagedPtr _obj+    return result'++-- method DBusArgInfo::unref+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusArgInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusArgInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_arg_info_unref" g_dbus_arg_info_unref :: +    Ptr DBusArgInfo ->                      -- _obj : TInterface "Gio" "DBusArgInfo"+    IO ()+++dBusArgInfoUnref ::+    (MonadIO m) =>+    DBusArgInfo ->                          -- _obj+    m ()+dBusArgInfoUnref _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    g_dbus_arg_info_unref _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Structs/DBusArgInfo.hs-boot view
@@ -0,0 +1,11 @@+module GI.Gio.Structs.DBusArgInfo where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype DBusArgInfo = DBusArgInfo (ForeignPtr DBusArgInfo)+instance BoxedObject DBusArgInfo where
+ GI/Gio/Structs/DBusErrorEntry.hs view
@@ -0,0 +1,56 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Struct used in g_dbus_error_register_error_domain().+-}++module GI.Gio.Structs.DBusErrorEntry+    ( ++-- * Exported types+    DBusErrorEntry(..)                      ,+    noDBusErrorEntry                        ,+++ -- * Properties+-- ** DbusErrorName+    dBusErrorEntryReadDbusErrorName         ,+++-- ** ErrorCode+    dBusErrorEntryReadErrorCode             ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks++newtype DBusErrorEntry = DBusErrorEntry (ForeignPtr DBusErrorEntry)+noDBusErrorEntry :: Maybe DBusErrorEntry+noDBusErrorEntry = Nothing++dBusErrorEntryReadErrorCode :: DBusErrorEntry -> IO Int32+dBusErrorEntryReadErrorCode s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO Int32+    return val++dBusErrorEntryReadDbusErrorName :: DBusErrorEntry -> IO T.Text+dBusErrorEntryReadDbusErrorName s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CString+    val' <- cstringToText val+    return val'++
+ GI/Gio/Structs/DBusErrorEntry.hs-boot view
@@ -0,0 +1,10 @@+module GI.Gio.Structs.DBusErrorEntry where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype DBusErrorEntry = DBusErrorEntry (ForeignPtr DBusErrorEntry)
+ GI/Gio/Structs/DBusInterfaceInfo.hs view
@@ -0,0 +1,359 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Information about a D-Bus interface.+-}++module GI.Gio.Structs.DBusInterfaceInfo+    ( ++-- * Exported types+    DBusInterfaceInfo(..)                   ,+    noDBusInterfaceInfo                     ,+++ -- * Methods+-- ** dBusInterfaceInfoCacheBuild+    dBusInterfaceInfoCacheBuild             ,+++-- ** dBusInterfaceInfoCacheRelease+    dBusInterfaceInfoCacheRelease           ,+++-- ** dBusInterfaceInfoGenerateXml+    dBusInterfaceInfoGenerateXml            ,+++-- ** dBusInterfaceInfoLookupMethod+    dBusInterfaceInfoLookupMethod           ,+++-- ** dBusInterfaceInfoLookupProperty+    dBusInterfaceInfoLookupProperty         ,+++-- ** dBusInterfaceInfoLookupSignal+    dBusInterfaceInfoLookupSignal           ,+++-- ** dBusInterfaceInfoRef+    dBusInterfaceInfoRef                    ,+++-- ** dBusInterfaceInfoUnref+    dBusInterfaceInfoUnref                  ,+++++ -- * Properties+-- ** Annotations+    dBusInterfaceInfoReadAnnotations        ,+++-- ** Methods+    dBusInterfaceInfoReadMethods            ,+++-- ** Name+    dBusInterfaceInfoReadName               ,+++-- ** Properties+    dBusInterfaceInfoReadProperties         ,+++-- ** RefCount+    dBusInterfaceInfoReadRefCount           ,+++-- ** Signals+    dBusInterfaceInfoReadSignals            ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib++newtype DBusInterfaceInfo = DBusInterfaceInfo (ForeignPtr DBusInterfaceInfo)+foreign import ccall "g_dbus_interface_info_get_type" c_g_dbus_interface_info_get_type :: +    IO GType++instance BoxedObject DBusInterfaceInfo where+    boxedType _ = c_g_dbus_interface_info_get_type++noDBusInterfaceInfo :: Maybe DBusInterfaceInfo+noDBusInterfaceInfo = Nothing++dBusInterfaceInfoReadRefCount :: DBusInterfaceInfo -> IO Int32+dBusInterfaceInfoReadRefCount s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO Int32+    return val++dBusInterfaceInfoReadName :: DBusInterfaceInfo -> IO T.Text+dBusInterfaceInfoReadName s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CString+    val' <- cstringToText val+    return val'++dBusInterfaceInfoReadMethods :: DBusInterfaceInfo -> IO [DBusMethodInfo]+dBusInterfaceInfoReadMethods s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO (Ptr (Ptr DBusMethodInfo))+    val' <- unpackZeroTerminatedPtrArray val+    val'' <- mapM (newBoxed DBusMethodInfo) val'+    return val''++dBusInterfaceInfoReadSignals :: DBusInterfaceInfo -> IO [DBusSignalInfo]+dBusInterfaceInfoReadSignals s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 24) :: IO (Ptr (Ptr DBusSignalInfo))+    val' <- unpackZeroTerminatedPtrArray val+    val'' <- mapM (newBoxed DBusSignalInfo) val'+    return val''++dBusInterfaceInfoReadProperties :: DBusInterfaceInfo -> IO [DBusPropertyInfo]+dBusInterfaceInfoReadProperties s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 32) :: IO (Ptr (Ptr DBusPropertyInfo))+    val' <- unpackZeroTerminatedPtrArray val+    val'' <- mapM (newBoxed DBusPropertyInfo) val'+    return val''++dBusInterfaceInfoReadAnnotations :: DBusInterfaceInfo -> IO [DBusAnnotationInfo]+dBusInterfaceInfoReadAnnotations s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 40) :: IO (Ptr (Ptr DBusAnnotationInfo))+    val' <- unpackZeroTerminatedPtrArray val+    val'' <- mapM (newBoxed DBusAnnotationInfo) val'+    return val''++-- method DBusInterfaceInfo::cache_build+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_interface_info_cache_build" g_dbus_interface_info_cache_build :: +    Ptr DBusInterfaceInfo ->                -- _obj : TInterface "Gio" "DBusInterfaceInfo"+    IO ()+++dBusInterfaceInfoCacheBuild ::+    (MonadIO m) =>+    DBusInterfaceInfo ->                    -- _obj+    m ()+dBusInterfaceInfoCacheBuild _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    g_dbus_interface_info_cache_build _obj'+    touchManagedPtr _obj+    return ()++-- method DBusInterfaceInfo::cache_release+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_interface_info_cache_release" g_dbus_interface_info_cache_release :: +    Ptr DBusInterfaceInfo ->                -- _obj : TInterface "Gio" "DBusInterfaceInfo"+    IO ()+++dBusInterfaceInfoCacheRelease ::+    (MonadIO m) =>+    DBusInterfaceInfo ->                    -- _obj+    m ()+dBusInterfaceInfoCacheRelease _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    g_dbus_interface_info_cache_release _obj'+    touchManagedPtr _obj+    return ()++-- method DBusInterfaceInfo::generate_xml+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "indent", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "string_builder", argType = TInterface "GLib" "String", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "indent", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_interface_info_generate_xml" g_dbus_interface_info_generate_xml :: +    Ptr DBusInterfaceInfo ->                -- _obj : TInterface "Gio" "DBusInterfaceInfo"+    Word32 ->                               -- indent : TBasicType TUInt32+    Ptr GLib.String ->                      -- string_builder : TInterface "GLib" "String"+    IO ()+++dBusInterfaceInfoGenerateXml ::+    (MonadIO m) =>+    DBusInterfaceInfo ->                    -- _obj+    Word32 ->                               -- indent+    m (GLib.String)+dBusInterfaceInfoGenerateXml _obj indent = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    string_builder <- callocBoxedBytes 24 :: IO (Ptr GLib.String)+    g_dbus_interface_info_generate_xml _obj' indent string_builder+    string_builder' <- (wrapBoxed GLib.String) string_builder+    touchManagedPtr _obj+    return string_builder'++-- method DBusInterfaceInfo::lookup_method+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusMethodInfo"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_interface_info_lookup_method" g_dbus_interface_info_lookup_method :: +    Ptr DBusInterfaceInfo ->                -- _obj : TInterface "Gio" "DBusInterfaceInfo"+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr DBusMethodInfo)+++dBusInterfaceInfoLookupMethod ::+    (MonadIO m) =>+    DBusInterfaceInfo ->                    -- _obj+    T.Text ->                               -- name+    m DBusMethodInfo+dBusInterfaceInfoLookupMethod _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    name' <- textToCString name+    result <- g_dbus_interface_info_lookup_method _obj' name'+    checkUnexpectedReturnNULL "g_dbus_interface_info_lookup_method" result+    result' <- (newBoxed DBusMethodInfo) result+    touchManagedPtr _obj+    freeMem name'+    return result'++-- method DBusInterfaceInfo::lookup_property+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusPropertyInfo"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_interface_info_lookup_property" g_dbus_interface_info_lookup_property :: +    Ptr DBusInterfaceInfo ->                -- _obj : TInterface "Gio" "DBusInterfaceInfo"+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr DBusPropertyInfo)+++dBusInterfaceInfoLookupProperty ::+    (MonadIO m) =>+    DBusInterfaceInfo ->                    -- _obj+    T.Text ->                               -- name+    m DBusPropertyInfo+dBusInterfaceInfoLookupProperty _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    name' <- textToCString name+    result <- g_dbus_interface_info_lookup_property _obj' name'+    checkUnexpectedReturnNULL "g_dbus_interface_info_lookup_property" result+    result' <- (newBoxed DBusPropertyInfo) result+    touchManagedPtr _obj+    freeMem name'+    return result'++-- method DBusInterfaceInfo::lookup_signal+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusSignalInfo"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_interface_info_lookup_signal" g_dbus_interface_info_lookup_signal :: +    Ptr DBusInterfaceInfo ->                -- _obj : TInterface "Gio" "DBusInterfaceInfo"+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr DBusSignalInfo)+++dBusInterfaceInfoLookupSignal ::+    (MonadIO m) =>+    DBusInterfaceInfo ->                    -- _obj+    T.Text ->                               -- name+    m DBusSignalInfo+dBusInterfaceInfoLookupSignal _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    name' <- textToCString name+    result <- g_dbus_interface_info_lookup_signal _obj' name'+    checkUnexpectedReturnNULL "g_dbus_interface_info_lookup_signal" result+    result' <- (newBoxed DBusSignalInfo) result+    touchManagedPtr _obj+    freeMem name'+    return result'++-- method DBusInterfaceInfo::ref+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusInterfaceInfo"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_interface_info_ref" g_dbus_interface_info_ref :: +    Ptr DBusInterfaceInfo ->                -- _obj : TInterface "Gio" "DBusInterfaceInfo"+    IO (Ptr DBusInterfaceInfo)+++dBusInterfaceInfoRef ::+    (MonadIO m) =>+    DBusInterfaceInfo ->                    -- _obj+    m DBusInterfaceInfo+dBusInterfaceInfoRef _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_dbus_interface_info_ref _obj'+    checkUnexpectedReturnNULL "g_dbus_interface_info_ref" result+    result' <- (wrapBoxed DBusInterfaceInfo) result+    touchManagedPtr _obj+    return result'++-- method DBusInterfaceInfo::unref+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusInterfaceInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_interface_info_unref" g_dbus_interface_info_unref :: +    Ptr DBusInterfaceInfo ->                -- _obj : TInterface "Gio" "DBusInterfaceInfo"+    IO ()+++dBusInterfaceInfoUnref ::+    (MonadIO m) =>+    DBusInterfaceInfo ->                    -- _obj+    m ()+dBusInterfaceInfoUnref _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    g_dbus_interface_info_unref _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Structs/DBusInterfaceInfo.hs-boot view
@@ -0,0 +1,11 @@+module GI.Gio.Structs.DBusInterfaceInfo where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype DBusInterfaceInfo = DBusInterfaceInfo (ForeignPtr DBusInterfaceInfo)+instance BoxedObject DBusInterfaceInfo where
+ GI/Gio/Structs/DBusInterfaceVTable.hs view
@@ -0,0 +1,80 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Virtual table for handling properties and method calls for a D-Bus+interface.++Since 2.38, if you want to handle getting/setting D-Bus properties+asynchronously, give %NULL as your get_property() or set_property()+function. The D-Bus call will be directed to your @method_call function,+with the provided @interface_name set to "org.freedesktop.DBus.Properties".++Ownership of the #GDBusMethodInvocation object passed to the+method_call() function is transferred to your handler; you must+call one of the methods of #GDBusMethodInvocation to return a reply+(possibly empty), or an error. These functions also take ownership+of the passed-in invocation object, so unless the invocation+object has otherwise been referenced, it will be then be freed.+Calling one of these functions may be done within your+method_call() implementation but it also can be done at a later+point to handle the method asynchronously.++The usual checks on the validity of the calls is performed. For+`Get` calls, an error is automatically returned if the property does+not exist or the permissions do not allow access. The same checks are+performed for `Set` calls, and the provided value is also checked for+being the correct type.++For both `Get` and `Set` calls, the #GDBusMethodInvocation+passed to the @method_call handler can be queried with+g_dbus_method_invocation_get_property_info() to get a pointer+to the #GDBusPropertyInfo of the property.++If you have readable properties specified in your interface info,+you must ensure that you either provide a non-%NULL @get_property()+function or provide implementations of both the `Get` and `GetAll`+methods on org.freedesktop.DBus.Properties interface in your @method_call+function. Note that the required return type of the `Get` call is+`(v)`, not the type of the property. `GetAll` expects a return value+of type `a{sv}`.++If you have writable properties specified in your interface info,+you must ensure that you either provide a non-%NULL @set_property()+function or provide an implementation of the `Set` call. If implementing+the call, you must return the value of type %G_VARIANT_TYPE_UNIT.+-}++module GI.Gio.Structs.DBusInterfaceVTable+    ( ++-- * Exported types+    DBusInterfaceVTable(..)                 ,+    noDBusInterfaceVTable                   ,+++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks++newtype DBusInterfaceVTable = DBusInterfaceVTable (ForeignPtr DBusInterfaceVTable)+noDBusInterfaceVTable :: Maybe DBusInterfaceVTable+noDBusInterfaceVTable = Nothing++-- XXX Skipped getter for "DBusInterfaceVTable:method_call" :: Not implemented: "Wrapping foreign callbacks is not supported yet"++-- XXX Skipped getter for "DBusInterfaceVTable:get_property" :: Not implemented: "Wrapping foreign callbacks is not supported yet"++-- XXX Skipped getter for "DBusInterfaceVTable:set_property" :: Not implemented: "Wrapping foreign callbacks is not supported yet"++
+ GI/Gio/Structs/DBusInterfaceVTable.hs-boot view
@@ -0,0 +1,10 @@+module GI.Gio.Structs.DBusInterfaceVTable where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype DBusInterfaceVTable = DBusInterfaceVTable (ForeignPtr DBusInterfaceVTable)
+ GI/Gio/Structs/DBusMethodInfo.hs view
@@ -0,0 +1,156 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Information about a method on an D-Bus interface.+-}++module GI.Gio.Structs.DBusMethodInfo+    ( ++-- * Exported types+    DBusMethodInfo(..)                      ,+    noDBusMethodInfo                        ,+++ -- * Methods+-- ** dBusMethodInfoRef+    dBusMethodInfoRef                       ,+++-- ** dBusMethodInfoUnref+    dBusMethodInfoUnref                     ,+++++ -- * Properties+-- ** Annotations+    dBusMethodInfoReadAnnotations           ,+++-- ** InArgs+    dBusMethodInfoReadInArgs                ,+++-- ** Name+    dBusMethodInfoReadName                  ,+++-- ** OutArgs+    dBusMethodInfoReadOutArgs               ,+++-- ** RefCount+    dBusMethodInfoReadRefCount              ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks++newtype DBusMethodInfo = DBusMethodInfo (ForeignPtr DBusMethodInfo)+foreign import ccall "g_dbus_method_info_get_type" c_g_dbus_method_info_get_type :: +    IO GType++instance BoxedObject DBusMethodInfo where+    boxedType _ = c_g_dbus_method_info_get_type++noDBusMethodInfo :: Maybe DBusMethodInfo+noDBusMethodInfo = Nothing++dBusMethodInfoReadRefCount :: DBusMethodInfo -> IO Int32+dBusMethodInfoReadRefCount s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO Int32+    return val++dBusMethodInfoReadName :: DBusMethodInfo -> IO T.Text+dBusMethodInfoReadName s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CString+    val' <- cstringToText val+    return val'++dBusMethodInfoReadInArgs :: DBusMethodInfo -> IO [DBusArgInfo]+dBusMethodInfoReadInArgs s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO (Ptr (Ptr DBusArgInfo))+    val' <- unpackZeroTerminatedPtrArray val+    val'' <- mapM (newBoxed DBusArgInfo) val'+    return val''++dBusMethodInfoReadOutArgs :: DBusMethodInfo -> IO [DBusArgInfo]+dBusMethodInfoReadOutArgs s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 24) :: IO (Ptr (Ptr DBusArgInfo))+    val' <- unpackZeroTerminatedPtrArray val+    val'' <- mapM (newBoxed DBusArgInfo) val'+    return val''++dBusMethodInfoReadAnnotations :: DBusMethodInfo -> IO [DBusAnnotationInfo]+dBusMethodInfoReadAnnotations s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 32) :: IO (Ptr (Ptr DBusAnnotationInfo))+    val' <- unpackZeroTerminatedPtrArray val+    val'' <- mapM (newBoxed DBusAnnotationInfo) val'+    return val''++-- method DBusMethodInfo::ref+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMethodInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMethodInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusMethodInfo"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_method_info_ref" g_dbus_method_info_ref :: +    Ptr DBusMethodInfo ->                   -- _obj : TInterface "Gio" "DBusMethodInfo"+    IO (Ptr DBusMethodInfo)+++dBusMethodInfoRef ::+    (MonadIO m) =>+    DBusMethodInfo ->                       -- _obj+    m DBusMethodInfo+dBusMethodInfoRef _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_dbus_method_info_ref _obj'+    checkUnexpectedReturnNULL "g_dbus_method_info_ref" result+    result' <- (wrapBoxed DBusMethodInfo) result+    touchManagedPtr _obj+    return result'++-- method DBusMethodInfo::unref+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMethodInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusMethodInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_method_info_unref" g_dbus_method_info_unref :: +    Ptr DBusMethodInfo ->                   -- _obj : TInterface "Gio" "DBusMethodInfo"+    IO ()+++dBusMethodInfoUnref ::+    (MonadIO m) =>+    DBusMethodInfo ->                       -- _obj+    m ()+dBusMethodInfoUnref _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    g_dbus_method_info_unref _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Structs/DBusMethodInfo.hs-boot view
@@ -0,0 +1,11 @@+module GI.Gio.Structs.DBusMethodInfo where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype DBusMethodInfo = DBusMethodInfo (ForeignPtr DBusMethodInfo)+instance BoxedObject DBusMethodInfo where
+ GI/Gio/Structs/DBusNodeInfo.hs view
@@ -0,0 +1,259 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Information about nodes in a remote object hierarchy.+-}++module GI.Gio.Structs.DBusNodeInfo+    ( ++-- * Exported types+    DBusNodeInfo(..)                        ,+    noDBusNodeInfo                          ,+++ -- * Methods+-- ** dBusNodeInfoGenerateXml+    dBusNodeInfoGenerateXml                 ,+++-- ** dBusNodeInfoLookupInterface+    dBusNodeInfoLookupInterface             ,+++-- ** dBusNodeInfoNewForXml+    dBusNodeInfoNewForXml                   ,+++-- ** dBusNodeInfoRef+    dBusNodeInfoRef                         ,+++-- ** dBusNodeInfoUnref+    dBusNodeInfoUnref                       ,+++++ -- * Properties+-- ** Annotations+    dBusNodeInfoReadAnnotations             ,+++-- ** Interfaces+    dBusNodeInfoReadInterfaces              ,+++-- ** Nodes+    dBusNodeInfoReadNodes                   ,+++-- ** Path+    dBusNodeInfoReadPath                    ,+++-- ** RefCount+    dBusNodeInfoReadRefCount                ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib++newtype DBusNodeInfo = DBusNodeInfo (ForeignPtr DBusNodeInfo)+foreign import ccall "g_dbus_node_info_get_type" c_g_dbus_node_info_get_type :: +    IO GType++instance BoxedObject DBusNodeInfo where+    boxedType _ = c_g_dbus_node_info_get_type++noDBusNodeInfo :: Maybe DBusNodeInfo+noDBusNodeInfo = Nothing++dBusNodeInfoReadRefCount :: DBusNodeInfo -> IO Int32+dBusNodeInfoReadRefCount s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO Int32+    return val++dBusNodeInfoReadPath :: DBusNodeInfo -> IO T.Text+dBusNodeInfoReadPath s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CString+    val' <- cstringToText val+    return val'++dBusNodeInfoReadInterfaces :: DBusNodeInfo -> IO [DBusInterfaceInfo]+dBusNodeInfoReadInterfaces s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO (Ptr (Ptr DBusInterfaceInfo))+    val' <- unpackZeroTerminatedPtrArray val+    val'' <- mapM (newBoxed DBusInterfaceInfo) val'+    return val''++dBusNodeInfoReadNodes :: DBusNodeInfo -> IO [DBusNodeInfo]+dBusNodeInfoReadNodes s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 24) :: IO (Ptr (Ptr DBusNodeInfo))+    val' <- unpackZeroTerminatedPtrArray val+    val'' <- mapM (newBoxed DBusNodeInfo) val'+    return val''++dBusNodeInfoReadAnnotations :: DBusNodeInfo -> IO [DBusAnnotationInfo]+dBusNodeInfoReadAnnotations s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 32) :: IO (Ptr (Ptr DBusAnnotationInfo))+    val' <- unpackZeroTerminatedPtrArray val+    val'' <- mapM (newBoxed DBusAnnotationInfo) val'+    return val''++-- method DBusNodeInfo::new_for_xml+-- method type : Constructor+-- Args : [Arg {argName = "xml_data", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "xml_data", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusNodeInfo"+-- throws : True+-- Skip return : False++foreign import ccall "g_dbus_node_info_new_for_xml" g_dbus_node_info_new_for_xml :: +    CString ->                              -- xml_data : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr DBusNodeInfo)+++dBusNodeInfoNewForXml ::+    (MonadIO m) =>+    T.Text ->                               -- xml_data+    m DBusNodeInfo+dBusNodeInfoNewForXml xml_data = liftIO $ do+    xml_data' <- textToCString xml_data+    onException (do+        result <- propagateGError $ g_dbus_node_info_new_for_xml xml_data'+        checkUnexpectedReturnNULL "g_dbus_node_info_new_for_xml" result+        result' <- (wrapBoxed DBusNodeInfo) result+        freeMem xml_data'+        return result'+     ) (do+        freeMem xml_data'+     )++-- method DBusNodeInfo::generate_xml+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusNodeInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "indent", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "string_builder", argType = TInterface "GLib" "String", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusNodeInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "indent", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_node_info_generate_xml" g_dbus_node_info_generate_xml :: +    Ptr DBusNodeInfo ->                     -- _obj : TInterface "Gio" "DBusNodeInfo"+    Word32 ->                               -- indent : TBasicType TUInt32+    Ptr GLib.String ->                      -- string_builder : TInterface "GLib" "String"+    IO ()+++dBusNodeInfoGenerateXml ::+    (MonadIO m) =>+    DBusNodeInfo ->                         -- _obj+    Word32 ->                               -- indent+    m (GLib.String)+dBusNodeInfoGenerateXml _obj indent = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    string_builder <- callocBoxedBytes 24 :: IO (Ptr GLib.String)+    g_dbus_node_info_generate_xml _obj' indent string_builder+    string_builder' <- (wrapBoxed GLib.String) string_builder+    touchManagedPtr _obj+    return string_builder'++-- method DBusNodeInfo::lookup_interface+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusNodeInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusNodeInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusInterfaceInfo"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_node_info_lookup_interface" g_dbus_node_info_lookup_interface :: +    Ptr DBusNodeInfo ->                     -- _obj : TInterface "Gio" "DBusNodeInfo"+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr DBusInterfaceInfo)+++dBusNodeInfoLookupInterface ::+    (MonadIO m) =>+    DBusNodeInfo ->                         -- _obj+    T.Text ->                               -- name+    m DBusInterfaceInfo+dBusNodeInfoLookupInterface _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    name' <- textToCString name+    result <- g_dbus_node_info_lookup_interface _obj' name'+    checkUnexpectedReturnNULL "g_dbus_node_info_lookup_interface" result+    result' <- (newBoxed DBusInterfaceInfo) result+    touchManagedPtr _obj+    freeMem name'+    return result'++-- method DBusNodeInfo::ref+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusNodeInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusNodeInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusNodeInfo"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_node_info_ref" g_dbus_node_info_ref :: +    Ptr DBusNodeInfo ->                     -- _obj : TInterface "Gio" "DBusNodeInfo"+    IO (Ptr DBusNodeInfo)+++dBusNodeInfoRef ::+    (MonadIO m) =>+    DBusNodeInfo ->                         -- _obj+    m DBusNodeInfo+dBusNodeInfoRef _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_dbus_node_info_ref _obj'+    checkUnexpectedReturnNULL "g_dbus_node_info_ref" result+    result' <- (wrapBoxed DBusNodeInfo) result+    touchManagedPtr _obj+    return result'++-- method DBusNodeInfo::unref+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusNodeInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusNodeInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_node_info_unref" g_dbus_node_info_unref :: +    Ptr DBusNodeInfo ->                     -- _obj : TInterface "Gio" "DBusNodeInfo"+    IO ()+++dBusNodeInfoUnref ::+    (MonadIO m) =>+    DBusNodeInfo ->                         -- _obj+    m ()+dBusNodeInfoUnref _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    g_dbus_node_info_unref _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Structs/DBusNodeInfo.hs-boot view
@@ -0,0 +1,11 @@+module GI.Gio.Structs.DBusNodeInfo where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype DBusNodeInfo = DBusNodeInfo (ForeignPtr DBusNodeInfo)+instance BoxedObject DBusNodeInfo where
+ GI/Gio/Structs/DBusPropertyInfo.hs view
@@ -0,0 +1,154 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Information about a D-Bus property on a D-Bus interface.+-}++module GI.Gio.Structs.DBusPropertyInfo+    ( ++-- * Exported types+    DBusPropertyInfo(..)                    ,+    noDBusPropertyInfo                      ,+++ -- * Methods+-- ** dBusPropertyInfoRef+    dBusPropertyInfoRef                     ,+++-- ** dBusPropertyInfoUnref+    dBusPropertyInfoUnref                   ,+++++ -- * Properties+-- ** Annotations+    dBusPropertyInfoReadAnnotations         ,+++-- ** Flags+    dBusPropertyInfoReadFlags               ,+++-- ** Name+    dBusPropertyInfoReadName                ,+++-- ** RefCount+    dBusPropertyInfoReadRefCount            ,+++-- ** Signature+    dBusPropertyInfoReadSignature           ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks++newtype DBusPropertyInfo = DBusPropertyInfo (ForeignPtr DBusPropertyInfo)+foreign import ccall "g_dbus_property_info_get_type" c_g_dbus_property_info_get_type :: +    IO GType++instance BoxedObject DBusPropertyInfo where+    boxedType _ = c_g_dbus_property_info_get_type++noDBusPropertyInfo :: Maybe DBusPropertyInfo+noDBusPropertyInfo = Nothing++dBusPropertyInfoReadRefCount :: DBusPropertyInfo -> IO Int32+dBusPropertyInfoReadRefCount s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO Int32+    return val++dBusPropertyInfoReadName :: DBusPropertyInfo -> IO T.Text+dBusPropertyInfoReadName s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CString+    val' <- cstringToText val+    return val'++dBusPropertyInfoReadSignature :: DBusPropertyInfo -> IO T.Text+dBusPropertyInfoReadSignature s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO CString+    val' <- cstringToText val+    return val'++dBusPropertyInfoReadFlags :: DBusPropertyInfo -> IO [DBusPropertyInfoFlags]+dBusPropertyInfoReadFlags s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 24) :: IO CUInt+    let val' = wordToGFlags val+    return val'++dBusPropertyInfoReadAnnotations :: DBusPropertyInfo -> IO [DBusAnnotationInfo]+dBusPropertyInfoReadAnnotations s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 32) :: IO (Ptr (Ptr DBusAnnotationInfo))+    val' <- unpackZeroTerminatedPtrArray val+    val'' <- mapM (newBoxed DBusAnnotationInfo) val'+    return val''++-- method DBusPropertyInfo::ref+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusPropertyInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusPropertyInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusPropertyInfo"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_property_info_ref" g_dbus_property_info_ref :: +    Ptr DBusPropertyInfo ->                 -- _obj : TInterface "Gio" "DBusPropertyInfo"+    IO (Ptr DBusPropertyInfo)+++dBusPropertyInfoRef ::+    (MonadIO m) =>+    DBusPropertyInfo ->                     -- _obj+    m DBusPropertyInfo+dBusPropertyInfoRef _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_dbus_property_info_ref _obj'+    checkUnexpectedReturnNULL "g_dbus_property_info_ref" result+    result' <- (wrapBoxed DBusPropertyInfo) result+    touchManagedPtr _obj+    return result'++-- method DBusPropertyInfo::unref+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusPropertyInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusPropertyInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_property_info_unref" g_dbus_property_info_unref :: +    Ptr DBusPropertyInfo ->                 -- _obj : TInterface "Gio" "DBusPropertyInfo"+    IO ()+++dBusPropertyInfoUnref ::+    (MonadIO m) =>+    DBusPropertyInfo ->                     -- _obj+    m ()+dBusPropertyInfoUnref _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    g_dbus_property_info_unref _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Structs/DBusPropertyInfo.hs-boot view
@@ -0,0 +1,11 @@+module GI.Gio.Structs.DBusPropertyInfo where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype DBusPropertyInfo = DBusPropertyInfo (ForeignPtr DBusPropertyInfo)+instance BoxedObject DBusPropertyInfo where
+ GI/Gio/Structs/DBusSignalInfo.hs view
@@ -0,0 +1,145 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Information about a signal on a D-Bus interface.+-}++module GI.Gio.Structs.DBusSignalInfo+    ( ++-- * Exported types+    DBusSignalInfo(..)                      ,+    noDBusSignalInfo                        ,+++ -- * Methods+-- ** dBusSignalInfoRef+    dBusSignalInfoRef                       ,+++-- ** dBusSignalInfoUnref+    dBusSignalInfoUnref                     ,+++++ -- * Properties+-- ** Annotations+    dBusSignalInfoReadAnnotations           ,+++-- ** Args+    dBusSignalInfoReadArgs                  ,+++-- ** Name+    dBusSignalInfoReadName                  ,+++-- ** RefCount+    dBusSignalInfoReadRefCount              ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks++newtype DBusSignalInfo = DBusSignalInfo (ForeignPtr DBusSignalInfo)+foreign import ccall "g_dbus_signal_info_get_type" c_g_dbus_signal_info_get_type :: +    IO GType++instance BoxedObject DBusSignalInfo where+    boxedType _ = c_g_dbus_signal_info_get_type++noDBusSignalInfo :: Maybe DBusSignalInfo+noDBusSignalInfo = Nothing++dBusSignalInfoReadRefCount :: DBusSignalInfo -> IO Int32+dBusSignalInfoReadRefCount s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO Int32+    return val++dBusSignalInfoReadName :: DBusSignalInfo -> IO T.Text+dBusSignalInfoReadName s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CString+    val' <- cstringToText val+    return val'++dBusSignalInfoReadArgs :: DBusSignalInfo -> IO [DBusArgInfo]+dBusSignalInfoReadArgs s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO (Ptr (Ptr DBusArgInfo))+    val' <- unpackZeroTerminatedPtrArray val+    val'' <- mapM (newBoxed DBusArgInfo) val'+    return val''++dBusSignalInfoReadAnnotations :: DBusSignalInfo -> IO [DBusAnnotationInfo]+dBusSignalInfoReadAnnotations s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 24) :: IO (Ptr (Ptr DBusAnnotationInfo))+    val' <- unpackZeroTerminatedPtrArray val+    val'' <- mapM (newBoxed DBusAnnotationInfo) val'+    return val''++-- method DBusSignalInfo::ref+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusSignalInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusSignalInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "DBusSignalInfo"+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_signal_info_ref" g_dbus_signal_info_ref :: +    Ptr DBusSignalInfo ->                   -- _obj : TInterface "Gio" "DBusSignalInfo"+    IO (Ptr DBusSignalInfo)+++dBusSignalInfoRef ::+    (MonadIO m) =>+    DBusSignalInfo ->                       -- _obj+    m DBusSignalInfo+dBusSignalInfoRef _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_dbus_signal_info_ref _obj'+    checkUnexpectedReturnNULL "g_dbus_signal_info_ref" result+    result' <- (wrapBoxed DBusSignalInfo) result+    touchManagedPtr _obj+    return result'++-- method DBusSignalInfo::unref+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusSignalInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "DBusSignalInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_dbus_signal_info_unref" g_dbus_signal_info_unref :: +    Ptr DBusSignalInfo ->                   -- _obj : TInterface "Gio" "DBusSignalInfo"+    IO ()+++dBusSignalInfoUnref ::+    (MonadIO m) =>+    DBusSignalInfo ->                       -- _obj+    m ()+dBusSignalInfoUnref _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    g_dbus_signal_info_unref _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Structs/DBusSignalInfo.hs-boot view
@@ -0,0 +1,11 @@+module GI.Gio.Structs.DBusSignalInfo where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype DBusSignalInfo = DBusSignalInfo (ForeignPtr DBusSignalInfo)+instance BoxedObject DBusSignalInfo where
+ GI/Gio/Structs/DBusSubtreeVTable.hs view
@@ -0,0 +1,38 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Virtual table for handling subtrees registered with g_dbus_connection_register_subtree().+-}++module GI.Gio.Structs.DBusSubtreeVTable+    ( ++-- * Exported types+    DBusSubtreeVTable(..)                   ,+    noDBusSubtreeVTable                     ,+++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks++newtype DBusSubtreeVTable = DBusSubtreeVTable (ForeignPtr DBusSubtreeVTable)+noDBusSubtreeVTable :: Maybe DBusSubtreeVTable+noDBusSubtreeVTable = Nothing++-- XXX Skipped getter for "DBusSubtreeVTable:introspect" :: Not implemented: "Wrapping foreign callbacks is not supported yet"++-- XXX Skipped getter for "DBusSubtreeVTable:dispatch" :: Not implemented: "Wrapping foreign callbacks is not supported yet"++
+ GI/Gio/Structs/DBusSubtreeVTable.hs-boot view
@@ -0,0 +1,10 @@+module GI.Gio.Structs.DBusSubtreeVTable where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype DBusSubtreeVTable = DBusSubtreeVTable (ForeignPtr DBusSubtreeVTable)
+ GI/Gio/Structs/FileAttributeInfo.hs view
@@ -0,0 +1,67 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Information about a specific attribute.+-}++module GI.Gio.Structs.FileAttributeInfo+    ( ++-- * Exported types+    FileAttributeInfo(..)                   ,+    noFileAttributeInfo                     ,+++ -- * Properties+-- ** Flags+    fileAttributeInfoReadFlags              ,+++-- ** Name+    fileAttributeInfoReadName               ,+++-- ** Type+    fileAttributeInfoReadType               ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks++newtype FileAttributeInfo = FileAttributeInfo (ForeignPtr FileAttributeInfo)+noFileAttributeInfo :: Maybe FileAttributeInfo+noFileAttributeInfo = Nothing++fileAttributeInfoReadName :: FileAttributeInfo -> IO T.Text+fileAttributeInfoReadName s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CString+    val' <- cstringToText val+    return val'++fileAttributeInfoReadType :: FileAttributeInfo -> IO FileAttributeType+fileAttributeInfoReadType s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++fileAttributeInfoReadFlags :: FileAttributeInfo -> IO [FileAttributeInfoFlags]+fileAttributeInfoReadFlags s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 12) :: IO CUInt+    let val' = wordToGFlags val+    return val'++
+ GI/Gio/Structs/FileAttributeInfo.hs-boot view
@@ -0,0 +1,10 @@+module GI.Gio.Structs.FileAttributeInfo where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype FileAttributeInfo = FileAttributeInfo (ForeignPtr FileAttributeInfo)
+ GI/Gio/Structs/FileAttributeInfoList.hs view
@@ -0,0 +1,252 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Acts as a lightweight registry for possible valid file attributes.+The registry stores Key-Value pair formats as #GFileAttributeInfos.+-}++module GI.Gio.Structs.FileAttributeInfoList+    ( ++-- * Exported types+    FileAttributeInfoList(..)               ,+    noFileAttributeInfoList                 ,+++ -- * Methods+-- ** fileAttributeInfoListAdd+    fileAttributeInfoListAdd                ,+++-- ** fileAttributeInfoListDup+    fileAttributeInfoListDup                ,+++-- ** fileAttributeInfoListLookup+    fileAttributeInfoListLookup             ,+++-- ** fileAttributeInfoListNew+    fileAttributeInfoListNew                ,+++-- ** fileAttributeInfoListRef+    fileAttributeInfoListRef                ,+++-- ** fileAttributeInfoListUnref+    fileAttributeInfoListUnref              ,+++++ -- * Properties+-- ** Infos+    fileAttributeInfoListReadInfos          ,+++-- ** NInfos+    fileAttributeInfoListReadNInfos         ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks++newtype FileAttributeInfoList = FileAttributeInfoList (ForeignPtr FileAttributeInfoList)+foreign import ccall "g_file_attribute_info_list_get_type" c_g_file_attribute_info_list_get_type :: +    IO GType++instance BoxedObject FileAttributeInfoList where+    boxedType _ = c_g_file_attribute_info_list_get_type++noFileAttributeInfoList :: Maybe FileAttributeInfoList+noFileAttributeInfoList = Nothing++fileAttributeInfoListReadInfos :: FileAttributeInfoList -> IO FileAttributeInfo+fileAttributeInfoListReadInfos s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr FileAttributeInfo)+    val' <- (newPtr 16 FileAttributeInfo) val+    return val'++fileAttributeInfoListReadNInfos :: FileAttributeInfoList -> IO Int32+fileAttributeInfoListReadNInfos s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO Int32+    return val++-- method FileAttributeInfoList::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gio" "FileAttributeInfoList"+-- throws : False+-- Skip return : False++foreign import ccall "g_file_attribute_info_list_new" g_file_attribute_info_list_new :: +    IO (Ptr FileAttributeInfoList)+++fileAttributeInfoListNew ::+    (MonadIO m) =>+    m FileAttributeInfoList+fileAttributeInfoListNew  = liftIO $ do+    result <- g_file_attribute_info_list_new+    checkUnexpectedReturnNULL "g_file_attribute_info_list_new" result+    result' <- (wrapBoxed FileAttributeInfoList) result+    return result'++-- method FileAttributeInfoList::add+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileAttributeInfoList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "Gio" "FileAttributeType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileAttributeInfoFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileAttributeInfoList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "Gio" "FileAttributeType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gio" "FileAttributeInfoFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_attribute_info_list_add" g_file_attribute_info_list_add :: +    Ptr FileAttributeInfoList ->            -- _obj : TInterface "Gio" "FileAttributeInfoList"+    CString ->                              -- name : TBasicType TUTF8+    CUInt ->                                -- type : TInterface "Gio" "FileAttributeType"+    CUInt ->                                -- flags : TInterface "Gio" "FileAttributeInfoFlags"+    IO ()+++fileAttributeInfoListAdd ::+    (MonadIO m) =>+    FileAttributeInfoList ->                -- _obj+    T.Text ->                               -- name+    FileAttributeType ->                    -- type+    [FileAttributeInfoFlags] ->             -- flags+    m ()+fileAttributeInfoListAdd _obj name type_ flags = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    name' <- textToCString name+    let type_' = (fromIntegral . fromEnum) type_+    let flags' = gflagsToWord flags+    g_file_attribute_info_list_add _obj' name' type_' flags'+    touchManagedPtr _obj+    freeMem name'+    return ()++-- method FileAttributeInfoList::dup+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileAttributeInfoList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileAttributeInfoList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileAttributeInfoList"+-- throws : False+-- Skip return : False++foreign import ccall "g_file_attribute_info_list_dup" g_file_attribute_info_list_dup :: +    Ptr FileAttributeInfoList ->            -- _obj : TInterface "Gio" "FileAttributeInfoList"+    IO (Ptr FileAttributeInfoList)+++fileAttributeInfoListDup ::+    (MonadIO m) =>+    FileAttributeInfoList ->                -- _obj+    m FileAttributeInfoList+fileAttributeInfoListDup _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_file_attribute_info_list_dup _obj'+    checkUnexpectedReturnNULL "g_file_attribute_info_list_dup" result+    result' <- (wrapBoxed FileAttributeInfoList) result+    touchManagedPtr _obj+    return result'++-- method FileAttributeInfoList::lookup+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileAttributeInfoList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileAttributeInfoList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileAttributeInfo"+-- throws : False+-- Skip return : False++foreign import ccall "g_file_attribute_info_list_lookup" g_file_attribute_info_list_lookup :: +    Ptr FileAttributeInfoList ->            -- _obj : TInterface "Gio" "FileAttributeInfoList"+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr FileAttributeInfo)+++fileAttributeInfoListLookup ::+    (MonadIO m) =>+    FileAttributeInfoList ->                -- _obj+    T.Text ->                               -- name+    m FileAttributeInfo+fileAttributeInfoListLookup _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    name' <- textToCString name+    result <- g_file_attribute_info_list_lookup _obj' name'+    checkUnexpectedReturnNULL "g_file_attribute_info_list_lookup" result+    result' <- (newPtr 16 FileAttributeInfo) result+    touchManagedPtr _obj+    freeMem name'+    return result'++-- method FileAttributeInfoList::ref+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileAttributeInfoList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileAttributeInfoList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileAttributeInfoList"+-- throws : False+-- Skip return : False++foreign import ccall "g_file_attribute_info_list_ref" g_file_attribute_info_list_ref :: +    Ptr FileAttributeInfoList ->            -- _obj : TInterface "Gio" "FileAttributeInfoList"+    IO (Ptr FileAttributeInfoList)+++fileAttributeInfoListRef ::+    (MonadIO m) =>+    FileAttributeInfoList ->                -- _obj+    m FileAttributeInfoList+fileAttributeInfoListRef _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_file_attribute_info_list_ref _obj'+    checkUnexpectedReturnNULL "g_file_attribute_info_list_ref" result+    result' <- (wrapBoxed FileAttributeInfoList) result+    touchManagedPtr _obj+    return result'++-- method FileAttributeInfoList::unref+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileAttributeInfoList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileAttributeInfoList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_attribute_info_list_unref" g_file_attribute_info_list_unref :: +    Ptr FileAttributeInfoList ->            -- _obj : TInterface "Gio" "FileAttributeInfoList"+    IO ()+++fileAttributeInfoListUnref ::+    (MonadIO m) =>+    FileAttributeInfoList ->                -- _obj+    m ()+fileAttributeInfoListUnref _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    g_file_attribute_info_list_unref _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Structs/FileAttributeInfoList.hs-boot view
@@ -0,0 +1,11 @@+module GI.Gio.Structs.FileAttributeInfoList where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype FileAttributeInfoList = FileAttributeInfoList (ForeignPtr FileAttributeInfoList)+instance BoxedObject FileAttributeInfoList where
+ GI/Gio/Structs/FileAttributeMatcher.hs view
@@ -0,0 +1,325 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Determines if a string matches a file attribute.+-}++module GI.Gio.Structs.FileAttributeMatcher+    ( ++-- * Exported types+    FileAttributeMatcher(..)                ,+    noFileAttributeMatcher                  ,+++ -- * Methods+-- ** fileAttributeMatcherEnumerateNamespace+    fileAttributeMatcherEnumerateNamespace  ,+++-- ** fileAttributeMatcherEnumerateNext+    fileAttributeMatcherEnumerateNext       ,+++-- ** fileAttributeMatcherMatches+    fileAttributeMatcherMatches             ,+++-- ** fileAttributeMatcherMatchesOnly+    fileAttributeMatcherMatchesOnly         ,+++-- ** fileAttributeMatcherNew+    fileAttributeMatcherNew                 ,+++-- ** fileAttributeMatcherRef+    fileAttributeMatcherRef                 ,+++-- ** fileAttributeMatcherSubtract+    fileAttributeMatcherSubtract            ,+++-- ** fileAttributeMatcherToString+    fileAttributeMatcherToString            ,+++-- ** fileAttributeMatcherUnref+    fileAttributeMatcherUnref               ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks++newtype FileAttributeMatcher = FileAttributeMatcher (ForeignPtr FileAttributeMatcher)+foreign import ccall "g_file_attribute_matcher_get_type" c_g_file_attribute_matcher_get_type :: +    IO GType++instance BoxedObject FileAttributeMatcher where+    boxedType _ = c_g_file_attribute_matcher_get_type++noFileAttributeMatcher :: Maybe FileAttributeMatcher+noFileAttributeMatcher = Nothing++-- method FileAttributeMatcher::new+-- method type : Constructor+-- Args : [Arg {argName = "attributes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "attributes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileAttributeMatcher"+-- throws : False+-- Skip return : False++foreign import ccall "g_file_attribute_matcher_new" g_file_attribute_matcher_new :: +    CString ->                              -- attributes : TBasicType TUTF8+    IO (Ptr FileAttributeMatcher)+++fileAttributeMatcherNew ::+    (MonadIO m) =>+    T.Text ->                               -- attributes+    m FileAttributeMatcher+fileAttributeMatcherNew attributes = liftIO $ do+    attributes' <- textToCString attributes+    result <- g_file_attribute_matcher_new attributes'+    checkUnexpectedReturnNULL "g_file_attribute_matcher_new" result+    result' <- (wrapBoxed FileAttributeMatcher) result+    freeMem attributes'+    return result'++-- method FileAttributeMatcher::enumerate_namespace+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileAttributeMatcher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "ns", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileAttributeMatcher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "ns", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_file_attribute_matcher_enumerate_namespace" g_file_attribute_matcher_enumerate_namespace :: +    Ptr FileAttributeMatcher ->             -- _obj : TInterface "Gio" "FileAttributeMatcher"+    CString ->                              -- ns : TBasicType TUTF8+    IO CInt+++fileAttributeMatcherEnumerateNamespace ::+    (MonadIO m) =>+    FileAttributeMatcher ->                 -- _obj+    T.Text ->                               -- ns+    m Bool+fileAttributeMatcherEnumerateNamespace _obj ns = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    ns' <- textToCString ns+    result <- g_file_attribute_matcher_enumerate_namespace _obj' ns'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem ns'+    return result'++-- method FileAttributeMatcher::enumerate_next+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileAttributeMatcher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileAttributeMatcher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_file_attribute_matcher_enumerate_next" g_file_attribute_matcher_enumerate_next :: +    Ptr FileAttributeMatcher ->             -- _obj : TInterface "Gio" "FileAttributeMatcher"+    IO CString+++fileAttributeMatcherEnumerateNext ::+    (MonadIO m) =>+    FileAttributeMatcher ->                 -- _obj+    m T.Text+fileAttributeMatcherEnumerateNext _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_file_attribute_matcher_enumerate_next _obj'+    checkUnexpectedReturnNULL "g_file_attribute_matcher_enumerate_next" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method FileAttributeMatcher::matches+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileAttributeMatcher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileAttributeMatcher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_file_attribute_matcher_matches" g_file_attribute_matcher_matches :: +    Ptr FileAttributeMatcher ->             -- _obj : TInterface "Gio" "FileAttributeMatcher"+    CString ->                              -- attribute : TBasicType TUTF8+    IO CInt+++fileAttributeMatcherMatches ::+    (MonadIO m) =>+    FileAttributeMatcher ->                 -- _obj+    T.Text ->                               -- attribute+    m Bool+fileAttributeMatcherMatches _obj attribute = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    attribute' <- textToCString attribute+    result <- g_file_attribute_matcher_matches _obj' attribute'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem attribute'+    return result'++-- method FileAttributeMatcher::matches_only+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileAttributeMatcher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileAttributeMatcher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attribute", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_file_attribute_matcher_matches_only" g_file_attribute_matcher_matches_only :: +    Ptr FileAttributeMatcher ->             -- _obj : TInterface "Gio" "FileAttributeMatcher"+    CString ->                              -- attribute : TBasicType TUTF8+    IO CInt+++fileAttributeMatcherMatchesOnly ::+    (MonadIO m) =>+    FileAttributeMatcher ->                 -- _obj+    T.Text ->                               -- attribute+    m Bool+fileAttributeMatcherMatchesOnly _obj attribute = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    attribute' <- textToCString attribute+    result <- g_file_attribute_matcher_matches_only _obj' attribute'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem attribute'+    return result'++-- method FileAttributeMatcher::ref+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileAttributeMatcher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileAttributeMatcher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileAttributeMatcher"+-- throws : False+-- Skip return : False++foreign import ccall "g_file_attribute_matcher_ref" g_file_attribute_matcher_ref :: +    Ptr FileAttributeMatcher ->             -- _obj : TInterface "Gio" "FileAttributeMatcher"+    IO (Ptr FileAttributeMatcher)+++fileAttributeMatcherRef ::+    (MonadIO m) =>+    FileAttributeMatcher ->                 -- _obj+    m FileAttributeMatcher+fileAttributeMatcherRef _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_file_attribute_matcher_ref _obj'+    checkUnexpectedReturnNULL "g_file_attribute_matcher_ref" result+    result' <- (wrapBoxed FileAttributeMatcher) result+    touchManagedPtr _obj+    return result'++-- method FileAttributeMatcher::subtract+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileAttributeMatcher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "subtract", argType = TInterface "Gio" "FileAttributeMatcher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileAttributeMatcher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "subtract", argType = TInterface "Gio" "FileAttributeMatcher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "FileAttributeMatcher"+-- throws : False+-- Skip return : False++foreign import ccall "g_file_attribute_matcher_subtract" g_file_attribute_matcher_subtract :: +    Ptr FileAttributeMatcher ->             -- _obj : TInterface "Gio" "FileAttributeMatcher"+    Ptr FileAttributeMatcher ->             -- subtract : TInterface "Gio" "FileAttributeMatcher"+    IO (Ptr FileAttributeMatcher)+++fileAttributeMatcherSubtract ::+    (MonadIO m) =>+    FileAttributeMatcher ->                 -- _obj+    FileAttributeMatcher ->                 -- subtract+    m FileAttributeMatcher+fileAttributeMatcherSubtract _obj subtract = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let subtract' = unsafeManagedPtrGetPtr subtract+    result <- g_file_attribute_matcher_subtract _obj' subtract'+    checkUnexpectedReturnNULL "g_file_attribute_matcher_subtract" result+    result' <- (wrapBoxed FileAttributeMatcher) result+    touchManagedPtr _obj+    touchManagedPtr subtract+    return result'++-- method FileAttributeMatcher::to_string+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileAttributeMatcher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileAttributeMatcher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_file_attribute_matcher_to_string" g_file_attribute_matcher_to_string :: +    Ptr FileAttributeMatcher ->             -- _obj : TInterface "Gio" "FileAttributeMatcher"+    IO CString+++fileAttributeMatcherToString ::+    (MonadIO m) =>+    FileAttributeMatcher ->                 -- _obj+    m T.Text+fileAttributeMatcherToString _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_file_attribute_matcher_to_string _obj'+    checkUnexpectedReturnNULL "g_file_attribute_matcher_to_string" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method FileAttributeMatcher::unref+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "FileAttributeMatcher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "FileAttributeMatcher", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_file_attribute_matcher_unref" g_file_attribute_matcher_unref :: +    Ptr FileAttributeMatcher ->             -- _obj : TInterface "Gio" "FileAttributeMatcher"+    IO ()+++fileAttributeMatcherUnref ::+    (MonadIO m) =>+    FileAttributeMatcher ->                 -- _obj+    m ()+fileAttributeMatcherUnref _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    g_file_attribute_matcher_unref _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Structs/FileAttributeMatcher.hs-boot view
@@ -0,0 +1,11 @@+module GI.Gio.Structs.FileAttributeMatcher where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype FileAttributeMatcher = FileAttributeMatcher (ForeignPtr FileAttributeMatcher)+instance BoxedObject FileAttributeMatcher where
+ GI/Gio/Structs/IOExtension.hs view
@@ -0,0 +1,125 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++#GIOExtension is an opaque data structure and can only be accessed+using the following functions.+-}++module GI.Gio.Structs.IOExtension+    ( ++-- * Exported types+    IOExtension(..)                         ,+    noIOExtension                           ,+++ -- * Methods+-- ** iOExtensionGetName+    iOExtensionGetName                      ,+++-- ** iOExtensionGetPriority+    iOExtensionGetPriority                  ,+++-- ** iOExtensionGetType+    iOExtensionGetType                      ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks++newtype IOExtension = IOExtension (ForeignPtr IOExtension)+noIOExtension :: Maybe IOExtension+noIOExtension = Nothing++-- method IOExtension::get_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "IOExtension", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "IOExtension", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_io_extension_get_name" g_io_extension_get_name :: +    Ptr IOExtension ->                      -- _obj : TInterface "Gio" "IOExtension"+    IO CString+++iOExtensionGetName ::+    (MonadIO m) =>+    IOExtension ->                          -- _obj+    m T.Text+iOExtensionGetName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_io_extension_get_name _obj'+    checkUnexpectedReturnNULL "g_io_extension_get_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method IOExtension::get_priority+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "IOExtension", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "IOExtension", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_io_extension_get_priority" g_io_extension_get_priority :: +    Ptr IOExtension ->                      -- _obj : TInterface "Gio" "IOExtension"+    IO Int32+++iOExtensionGetPriority ::+    (MonadIO m) =>+    IOExtension ->                          -- _obj+    m Int32+iOExtensionGetPriority _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_io_extension_get_priority _obj'+    touchManagedPtr _obj+    return result++-- method IOExtension::get_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "IOExtension", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "IOExtension", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TGType+-- throws : False+-- Skip return : False++foreign import ccall "g_io_extension_get_type" g_io_extension_get_type :: +    Ptr IOExtension ->                      -- _obj : TInterface "Gio" "IOExtension"+    IO CGType+++iOExtensionGetType ::+    (MonadIO m) =>+    IOExtension ->                          -- _obj+    m GType+iOExtensionGetType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_io_extension_get_type _obj'+    let result' = GType result+    touchManagedPtr _obj+    return result'++
+ GI/Gio/Structs/IOExtension.hs-boot view
@@ -0,0 +1,10 @@+module GI.Gio.Structs.IOExtension where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype IOExtension = IOExtension (ForeignPtr IOExtension)
+ GI/Gio/Structs/IOExtensionPoint.hs view
@@ -0,0 +1,165 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++#GIOExtensionPoint is an opaque data structure and can only be accessed+using the following functions.+-}++module GI.Gio.Structs.IOExtensionPoint+    ( ++-- * Exported types+    IOExtensionPoint(..)                    ,+    noIOExtensionPoint                      ,+++ -- * Methods+-- ** iOExtensionPointGetExtensionByName+    iOExtensionPointGetExtensionByName      ,+++-- ** iOExtensionPointGetExtensions+    iOExtensionPointGetExtensions           ,+++-- ** iOExtensionPointGetRequiredType+    iOExtensionPointGetRequiredType         ,+++-- ** iOExtensionPointSetRequiredType+    iOExtensionPointSetRequiredType         ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks++newtype IOExtensionPoint = IOExtensionPoint (ForeignPtr IOExtensionPoint)+noIOExtensionPoint :: Maybe IOExtensionPoint+noIOExtensionPoint = Nothing++-- method IOExtensionPoint::get_extension_by_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "IOExtensionPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "IOExtensionPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "IOExtension"+-- throws : False+-- Skip return : False++foreign import ccall "g_io_extension_point_get_extension_by_name" g_io_extension_point_get_extension_by_name :: +    Ptr IOExtensionPoint ->                 -- _obj : TInterface "Gio" "IOExtensionPoint"+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr IOExtension)+++iOExtensionPointGetExtensionByName ::+    (MonadIO m) =>+    IOExtensionPoint ->                     -- _obj+    T.Text ->                               -- name+    m IOExtension+iOExtensionPointGetExtensionByName _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    name' <- textToCString name+    result <- g_io_extension_point_get_extension_by_name _obj' name'+    checkUnexpectedReturnNULL "g_io_extension_point_get_extension_by_name" result+    -- XXX Wrapping a foreign struct/union with no known destructor, leak?+    result' <- (\x -> IOExtension <$> newForeignPtr_ x) result+    touchManagedPtr _obj+    freeMem name'+    return result'++-- method IOExtensionPoint::get_extensions+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "IOExtensionPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "IOExtensionPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gio" "IOExtension")+-- throws : False+-- Skip return : False++foreign import ccall "g_io_extension_point_get_extensions" g_io_extension_point_get_extensions :: +    Ptr IOExtensionPoint ->                 -- _obj : TInterface "Gio" "IOExtensionPoint"+    IO (Ptr (GList (Ptr IOExtension)))+++iOExtensionPointGetExtensions ::+    (MonadIO m) =>+    IOExtensionPoint ->                     -- _obj+    m [IOExtension]+iOExtensionPointGetExtensions _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_io_extension_point_get_extensions _obj'+    checkUnexpectedReturnNULL "g_io_extension_point_get_extensions" result+    -- XXX Wrapping a foreign struct/union with no known destructor, leak?+    result' <- unpackGList result+    result'' <- mapM (\x -> IOExtension <$> newForeignPtr_ x) result'+    touchManagedPtr _obj+    return result''++-- method IOExtensionPoint::get_required_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "IOExtensionPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "IOExtensionPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TGType+-- throws : False+-- Skip return : False++foreign import ccall "g_io_extension_point_get_required_type" g_io_extension_point_get_required_type :: +    Ptr IOExtensionPoint ->                 -- _obj : TInterface "Gio" "IOExtensionPoint"+    IO CGType+++iOExtensionPointGetRequiredType ::+    (MonadIO m) =>+    IOExtensionPoint ->                     -- _obj+    m GType+iOExtensionPointGetRequiredType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_io_extension_point_get_required_type _obj'+    let result' = GType result+    touchManagedPtr _obj+    return result'++-- method IOExtensionPoint::set_required_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "IOExtensionPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "IOExtensionPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_io_extension_point_set_required_type" g_io_extension_point_set_required_type :: +    Ptr IOExtensionPoint ->                 -- _obj : TInterface "Gio" "IOExtensionPoint"+    CGType ->                               -- type : TBasicType TGType+    IO ()+++iOExtensionPointSetRequiredType ::+    (MonadIO m) =>+    IOExtensionPoint ->                     -- _obj+    GType ->                                -- type+    m ()+iOExtensionPointSetRequiredType _obj type_ = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let type_' = gtypeToCGType type_+    g_io_extension_point_set_required_type _obj' type_'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Structs/IOExtensionPoint.hs-boot view
@@ -0,0 +1,10 @@+module GI.Gio.Structs.IOExtensionPoint where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype IOExtensionPoint = IOExtensionPoint (ForeignPtr IOExtensionPoint)
+ GI/Gio/Structs/IOModuleScope.hs view
@@ -0,0 +1,101 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Represents a scope for loading IO modules. A scope can be used for blocking+duplicate modules, or blocking a module you don't want to load.++The scope can be used with g_io_modules_load_all_in_directory_with_scope()+or g_io_modules_scan_all_in_directory_with_scope().+-}++module GI.Gio.Structs.IOModuleScope+    ( ++-- * Exported types+    IOModuleScope(..)                       ,+    noIOModuleScope                         ,+++ -- * Methods+-- ** iOModuleScopeBlock+    iOModuleScopeBlock                      ,+++-- ** iOModuleScopeFree+    iOModuleScopeFree                       ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks++newtype IOModuleScope = IOModuleScope (ForeignPtr IOModuleScope)+noIOModuleScope :: Maybe IOModuleScope+noIOModuleScope = Nothing++-- method IOModuleScope::block+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "IOModuleScope", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "basename", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "IOModuleScope", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "basename", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_io_module_scope_block" g_io_module_scope_block :: +    Ptr IOModuleScope ->                    -- _obj : TInterface "Gio" "IOModuleScope"+    CString ->                              -- basename : TBasicType TUTF8+    IO ()+++iOModuleScopeBlock ::+    (MonadIO m) =>+    IOModuleScope ->                        -- _obj+    T.Text ->                               -- basename+    m ()+iOModuleScopeBlock _obj basename = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    basename' <- textToCString basename+    g_io_module_scope_block _obj' basename'+    touchManagedPtr _obj+    freeMem basename'+    return ()++-- method IOModuleScope::free+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "IOModuleScope", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "IOModuleScope", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_io_module_scope_free" g_io_module_scope_free :: +    Ptr IOModuleScope ->                    -- _obj : TInterface "Gio" "IOModuleScope"+    IO ()+++iOModuleScopeFree ::+    (MonadIO m) =>+    IOModuleScope ->                        -- _obj+    m ()+iOModuleScopeFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    g_io_module_scope_free _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Structs/IOModuleScope.hs-boot view
@@ -0,0 +1,10 @@+module GI.Gio.Structs.IOModuleScope where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype IOModuleScope = IOModuleScope (ForeignPtr IOModuleScope)
+ GI/Gio/Structs/IOSchedulerJob.hs view
@@ -0,0 +1,109 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Opaque class for defining and scheduling IO jobs.+-}++module GI.Gio.Structs.IOSchedulerJob+    ( ++-- * Exported types+    IOSchedulerJob(..)                      ,+    noIOSchedulerJob                        ,+++ -- * Methods+-- ** iOSchedulerJobSendToMainloop+    iOSchedulerJobSendToMainloop            ,+++-- ** iOSchedulerJobSendToMainloopAsync+    iOSchedulerJobSendToMainloopAsync       ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib++newtype IOSchedulerJob = IOSchedulerJob (ForeignPtr IOSchedulerJob)+noIOSchedulerJob :: Maybe IOSchedulerJob+noIOSchedulerJob = Nothing++-- method IOSchedulerJob::send_to_mainloop+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "IOSchedulerJob", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "GLib" "SourceFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "IOSchedulerJob", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "GLib" "SourceFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_io_scheduler_job_send_to_mainloop" g_io_scheduler_job_send_to_mainloop :: +    Ptr IOSchedulerJob ->                   -- _obj : TInterface "Gio" "IOSchedulerJob"+    FunPtr GLib.SourceFuncC ->              -- func : TInterface "GLib" "SourceFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"+    IO CInt++{-# DEPRECATED iOSchedulerJobSendToMainloop ["Use g_main_context_invoke()."]#-}+iOSchedulerJobSendToMainloop ::+    (MonadIO m) =>+    IOSchedulerJob ->                       -- _obj+    GLib.SourceFunc ->                      -- func+    m Bool+iOSchedulerJobSendToMainloop _obj func = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    func' <- GLib.mkSourceFunc (GLib.sourceFuncWrapper Nothing func)+    let user_data = castFunPtrToPtr func'+    let notify = safeFreeFunPtrPtr+    result <- g_io_scheduler_job_send_to_mainloop _obj' func' user_data notify+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method IOSchedulerJob::send_to_mainloop_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "IOSchedulerJob", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "GLib" "SourceFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "IOSchedulerJob", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "GLib" "SourceFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_io_scheduler_job_send_to_mainloop_async" g_io_scheduler_job_send_to_mainloop_async :: +    Ptr IOSchedulerJob ->                   -- _obj : TInterface "Gio" "IOSchedulerJob"+    FunPtr GLib.SourceFuncC ->              -- func : TInterface "GLib" "SourceFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"+    IO ()++{-# DEPRECATED iOSchedulerJobSendToMainloopAsync ["Use g_main_context_invoke()."]#-}+iOSchedulerJobSendToMainloopAsync ::+    (MonadIO m) =>+    IOSchedulerJob ->                       -- _obj+    GLib.SourceFunc ->                      -- func+    m ()+iOSchedulerJobSendToMainloopAsync _obj func = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    func' <- GLib.mkSourceFunc (GLib.sourceFuncWrapper Nothing func)+    let user_data = castFunPtrToPtr func'+    let notify = safeFreeFunPtrPtr+    g_io_scheduler_job_send_to_mainloop_async _obj' func' user_data notify+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Structs/IOSchedulerJob.hs-boot view
@@ -0,0 +1,10 @@+module GI.Gio.Structs.IOSchedulerJob where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype IOSchedulerJob = IOSchedulerJob (ForeignPtr IOSchedulerJob)
+ GI/Gio/Structs/IOStreamAdapter.hs view
@@ -0,0 +1,32 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)+-}++module GI.Gio.Structs.IOStreamAdapter+    ( ++-- * Exported types+    IOStreamAdapter(..)                     ,+    noIOStreamAdapter                       ,+++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks++newtype IOStreamAdapter = IOStreamAdapter (ForeignPtr IOStreamAdapter)+noIOStreamAdapter :: Maybe IOStreamAdapter+noIOStreamAdapter = Nothing++
+ GI/Gio/Structs/IOStreamAdapter.hs-boot view
@@ -0,0 +1,10 @@+module GI.Gio.Structs.IOStreamAdapter where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype IOStreamAdapter = IOStreamAdapter (ForeignPtr IOStreamAdapter)
+ GI/Gio/Structs/InputVector.hs view
@@ -0,0 +1,58 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Structure used for scatter/gather data input.+You generally pass in an array of #GInputVectors+and the operation will store the read data starting in the+first buffer, switching to the next as needed.+-}++module GI.Gio.Structs.InputVector+    ( ++-- * Exported types+    InputVector(..)                         ,+    noInputVector                           ,+++ -- * Properties+-- ** Buffer+    inputVectorReadBuffer                   ,+++-- ** Size+    inputVectorReadSize                     ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks++newtype InputVector = InputVector (ForeignPtr InputVector)+noInputVector :: Maybe InputVector+noInputVector = Nothing++inputVectorReadBuffer :: InputVector -> IO (Ptr ())+inputVectorReadBuffer s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr ())+    return val++inputVectorReadSize :: InputVector -> IO Word64+inputVectorReadSize s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO Word64+    return val++
+ GI/Gio/Structs/InputVector.hs-boot view
@@ -0,0 +1,10 @@+module GI.Gio.Structs.InputVector where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype InputVector = InputVector (ForeignPtr InputVector)
+ GI/Gio/Structs/NativeSocketAddress.hs view
@@ -0,0 +1,34 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++An socket address of some unknown native type.+-}++module GI.Gio.Structs.NativeSocketAddress+    ( ++-- * Exported types+    NativeSocketAddress(..)                 ,+    noNativeSocketAddress                   ,+++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks++newtype NativeSocketAddress = NativeSocketAddress (ForeignPtr NativeSocketAddress)+noNativeSocketAddress :: Maybe NativeSocketAddress+noNativeSocketAddress = Nothing++
+ GI/Gio/Structs/NativeSocketAddress.hs-boot view
@@ -0,0 +1,10 @@+module GI.Gio.Structs.NativeSocketAddress where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype NativeSocketAddress = NativeSocketAddress (ForeignPtr NativeSocketAddress)
+ GI/Gio/Structs/OutputMessage.hs view
@@ -0,0 +1,92 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Structure used for scatter/gather data output when sending multiple+messages or packets in one go. You generally pass in an array of+#GOutputVectors and the operation will use all the buffers as if they+were one buffer.++If @address is %NULL then the message is sent to the default receiver+(as previously set by g_socket_connect()).+-}++module GI.Gio.Structs.OutputMessage+    ( ++-- * Exported types+    OutputMessage(..)                       ,+    noOutputMessage                         ,+++ -- * Properties+-- ** Address+    outputMessageReadAddress                ,+++-- ** BytesSent+    outputMessageReadBytesSent              ,+++-- ** NumControlMessages+    outputMessageReadNumControlMessages     ,+++-- ** NumVectors+    outputMessageReadNumVectors             ,+++-- ** Vectors+    outputMessageReadVectors                ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks++newtype OutputMessage = OutputMessage (ForeignPtr OutputMessage)+noOutputMessage :: Maybe OutputMessage+noOutputMessage = Nothing++outputMessageReadAddress :: OutputMessage -> IO SocketAddress+outputMessageReadAddress s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr SocketAddress)+    val' <- (newObject SocketAddress) val+    return val'++outputMessageReadVectors :: OutputMessage -> IO OutputVector+outputMessageReadVectors s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO (Ptr OutputVector)+    val' <- (newPtr 16 OutputVector) val+    return val'++outputMessageReadNumVectors :: OutputMessage -> IO Word32+outputMessageReadNumVectors s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO Word32+    return val++outputMessageReadBytesSent :: OutputMessage -> IO Word32+outputMessageReadBytesSent s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 20) :: IO Word32+    return val++-- XXX Skipped getter for "OutputMessage:control_messages" :: Not implemented: "Don't know how to unpack C array of type TCArray False (-1) 5 (TInterface \"Gio\" \"SocketControlMessage\")"++outputMessageReadNumControlMessages :: OutputMessage -> IO Word32+outputMessageReadNumControlMessages s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 32) :: IO Word32+    return val++
+ GI/Gio/Structs/OutputMessage.hs-boot view
@@ -0,0 +1,10 @@+module GI.Gio.Structs.OutputMessage where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype OutputMessage = OutputMessage (ForeignPtr OutputMessage)
+ GI/Gio/Structs/OutputVector.hs view
@@ -0,0 +1,58 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Structure used for scatter/gather data output.+You generally pass in an array of #GOutputVectors+and the operation will use all the buffers as if they were+one buffer.+-}++module GI.Gio.Structs.OutputVector+    ( ++-- * Exported types+    OutputVector(..)                        ,+    noOutputVector                          ,+++ -- * Properties+-- ** Buffer+    outputVectorReadBuffer                  ,+++-- ** Size+    outputVectorReadSize                    ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks++newtype OutputVector = OutputVector (ForeignPtr OutputVector)+noOutputVector :: Maybe OutputVector+noOutputVector = Nothing++outputVectorReadBuffer :: OutputVector -> IO (Ptr ())+outputVectorReadBuffer s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr ())+    return val++outputVectorReadSize :: OutputVector -> IO Word64+outputVectorReadSize s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO Word64+    return val++
+ GI/Gio/Structs/OutputVector.hs-boot view
@@ -0,0 +1,10 @@+module GI.Gio.Structs.OutputVector where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype OutputVector = OutputVector (ForeignPtr OutputVector)
+ GI/Gio/Structs/Resource.hs view
@@ -0,0 +1,400 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Applications and libraries often contain binary or textual data that is+really part of the application, rather than user data. For instance+#GtkBuilder .ui files, splashscreen images, GMenu markup XML, CSS files,+icons, etc. These are often shipped as files in `$datadir/appname`, or+manually included as literal strings in the code.++The #GResource API and the [glib-compile-resources][glib-compile-resources] program+provide a convenient and efficient alternative to this which has some nice properties. You+maintain the files as normal files, so its easy to edit them, but during the build the files+are combined into a binary bundle that is linked into the executable. This means that loading+the resource files are efficient (as they are already in memory, shared with other instances) and+simple (no need to check for things like I/O errors or locate the files in the filesystem). It+also makes it easier to create relocatable applications.++Resource files can also be marked as compressed. Such files will be included in the resource bundle+in a compressed form, but will be automatically uncompressed when the resource is used. This+is very useful e.g. for larger text files that are parsed once (or rarely) and then thrown away.++Resource files can also be marked to be preprocessed, by setting the value of the+`preprocess` attribute to a comma-separated list of preprocessing options.+The only options currently supported are:++`xml-stripblanks` which will use the xmllint command+to strip ignorable whitespace from the XML file. For this to work,+the `XMLLINT` environment variable must be set to the full path to+the xmllint executable, or xmllint must be in the `PATH`; otherwise+the preprocessing step is skipped.++`to-pixdata` which will use the gdk-pixbuf-pixdata command to convert+images to the GdkPixdata format, which allows you to create pixbufs directly using the data inside+the resource file, rather than an (uncompressed) copy if it. For this, the gdk-pixbuf-pixdata+program must be in the PATH, or the `GDK_PIXBUF_PIXDATA` environment variable must be+set to the full path to the gdk-pixbuf-pixdata executable; otherwise the resource compiler will+abort.++Resource bundles are created by the [glib-compile-resources][glib-compile-resources] program+which takes an XML file that describes the bundle, and a set of files that the XML references. These+are combined into a binary resource bundle.++An example resource description:+|[+<?xml version="1.0" encoding="UTF-8"?>+<gresources>+  <gresource prefix="/org/gtk/Example">+    <file>data/splashscreen.png</file>+    <file compressed="true">dialog.ui</file>+    <file preprocess="xml-stripblanks">menumarkup.xml</file>+  </gresource>+</gresources>+]|++This will create a resource bundle with the following files:+|[+/org/gtk/Example/data/splashscreen.png+/org/gtk/Example/dialog.ui+/org/gtk/Example/menumarkup.xml+]|++Note that all resources in the process share the same namespace, so use Java-style+path prefixes (like in the above example) to avoid conflicts.++You can then use [glib-compile-resources][glib-compile-resources] to compile the XML to a+binary bundle that you can load with g_resource_load(). However, its more common to use the --generate-source and+--generate-header arguments to create a source file and header to link directly into your application.+This will generate `get_resource()`, `register_resource()` and+`unregister_resource()` functions, prefixed by the `--c-name` argument passed+to [glib-compile-resources][glib-compile-resources]. `get_resource()` returns+the generated #GResource object. The register and unregister functions+register the resource so its files can be accessed using+g_resources_lookup_data().++Once a #GResource has been created and registered all the data in it can be accessed globally in the process by+using API calls like g_resources_open_stream() to stream the data or g_resources_lookup_data() to get a direct pointer+to the data. You can also use URIs like "resource:///org/gtk/Example/data/splashscreen.png" with #GFile to access+the resource data.++There are two forms of the generated source, the default version uses the compiler support for constructor+and destructor functions (where available) to automatically create and register the #GResource on startup+or library load time. If you pass --manual-register two functions to register/unregister the resource is instead+created. This requires an explicit initialization call in your application/library, but it works on all platforms,+even on the minor ones where this is not available. (Constructor support is available for at least Win32, Mac OS and Linux.)++Note that resource data can point directly into the data segment of e.g. a library, so if you are unloading libraries+during runtime you need to be very careful with keeping around pointers to data from a resource, as this goes away+when the library is unloaded. However, in practice this is not generally a problem, since most resource accesses+is for your own resources, and resource data is often used once, during parsing, and then released.+-}++module GI.Gio.Structs.Resource+    ( ++-- * Exported types+    Resource(..)                            ,+    noResource                              ,+++ -- * Methods+-- ** resourceEnumerateChildren+    resourceEnumerateChildren               ,+++-- ** resourceGetInfo+    resourceGetInfo                         ,+++-- ** resourceLookupData+    resourceLookupData                      ,+++-- ** resourceNewFromData+    resourceNewFromData                     ,+++-- ** resourceOpenStream+    resourceOpenStream                      ,+++-- ** resourceRef+    resourceRef                             ,+++-- ** resourceUnref+    resourceUnref                           ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib++newtype Resource = Resource (ForeignPtr Resource)+foreign import ccall "g_resource_get_type" c_g_resource_get_type :: +    IO GType++instance BoxedObject Resource where+    boxedType _ = c_g_resource_get_type++noResource :: Maybe Resource+noResource = Nothing++-- method Resource::new_from_data+-- method type : Constructor+-- Args : [Arg {argName = "data", argType = TInterface "GLib" "Bytes", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "data", argType = TInterface "GLib" "Bytes", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Resource"+-- throws : True+-- Skip return : False++foreign import ccall "g_resource_new_from_data" g_resource_new_from_data :: +    Ptr GLib.Bytes ->                       -- data : TInterface "GLib" "Bytes"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Resource)+++resourceNewFromData ::+    (MonadIO m) =>+    GLib.Bytes ->                           -- data+    m Resource+resourceNewFromData data_ = liftIO $ do+    let data_' = unsafeManagedPtrGetPtr data_+    onException (do+        result <- propagateGError $ g_resource_new_from_data data_'+        checkUnexpectedReturnNULL "g_resource_new_from_data" result+        result' <- (wrapBoxed Resource) result+        touchManagedPtr data_+        return result'+     ) (do+        return ()+     )++-- method Resource::enumerate_children+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Resource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "lookup_flags", argType = TInterface "Gio" "ResourceLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Resource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "lookup_flags", argType = TInterface "Gio" "ResourceLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : True+-- Skip return : False++foreign import ccall "g_resource_enumerate_children" g_resource_enumerate_children :: +    Ptr Resource ->                         -- _obj : TInterface "Gio" "Resource"+    CString ->                              -- path : TBasicType TUTF8+    CUInt ->                                -- lookup_flags : TInterface "Gio" "ResourceLookupFlags"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr CString)+++resourceEnumerateChildren ::+    (MonadIO m) =>+    Resource ->                             -- _obj+    T.Text ->                               -- path+    [ResourceLookupFlags] ->                -- lookup_flags+    m [T.Text]+resourceEnumerateChildren _obj path lookup_flags = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    path' <- textToCString path+    let lookup_flags' = gflagsToWord lookup_flags+    onException (do+        result <- propagateGError $ g_resource_enumerate_children _obj' path' lookup_flags'+        checkUnexpectedReturnNULL "g_resource_enumerate_children" result+        result' <- unpackZeroTerminatedUTF8CArray result+        mapZeroTerminatedCArray freeMem result+        freeMem result+        touchManagedPtr _obj+        freeMem path'+        return result'+     ) (do+        freeMem path'+     )++-- method Resource::get_info+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Resource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "lookup_flags", argType = TInterface "Gio" "ResourceLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "flags", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Resource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "lookup_flags", argType = TInterface "Gio" "ResourceLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "g_resource_get_info" g_resource_get_info :: +    Ptr Resource ->                         -- _obj : TInterface "Gio" "Resource"+    CString ->                              -- path : TBasicType TUTF8+    CUInt ->                                -- lookup_flags : TInterface "Gio" "ResourceLookupFlags"+    Ptr Word64 ->                           -- size : TBasicType TUInt64+    Ptr Word32 ->                           -- flags : TBasicType TUInt32+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++resourceGetInfo ::+    (MonadIO m) =>+    Resource ->                             -- _obj+    T.Text ->                               -- path+    [ResourceLookupFlags] ->                -- lookup_flags+    m (Word64,Word32)+resourceGetInfo _obj path lookup_flags = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    path' <- textToCString path+    let lookup_flags' = gflagsToWord lookup_flags+    size <- allocMem :: IO (Ptr Word64)+    flags <- allocMem :: IO (Ptr Word32)+    onException (do+        _ <- propagateGError $ g_resource_get_info _obj' path' lookup_flags' size flags+        size' <- peek size+        flags' <- peek flags+        touchManagedPtr _obj+        freeMem path'+        freeMem size+        freeMem flags+        return (size', flags')+     ) (do+        freeMem path'+        freeMem size+        freeMem flags+     )++-- method Resource::lookup_data+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Resource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "lookup_flags", argType = TInterface "Gio" "ResourceLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Resource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "lookup_flags", argType = TInterface "Gio" "ResourceLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GLib" "Bytes"+-- throws : True+-- Skip return : False++foreign import ccall "g_resource_lookup_data" g_resource_lookup_data :: +    Ptr Resource ->                         -- _obj : TInterface "Gio" "Resource"+    CString ->                              -- path : TBasicType TUTF8+    CUInt ->                                -- lookup_flags : TInterface "Gio" "ResourceLookupFlags"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr GLib.Bytes)+++resourceLookupData ::+    (MonadIO m) =>+    Resource ->                             -- _obj+    T.Text ->                               -- path+    [ResourceLookupFlags] ->                -- lookup_flags+    m GLib.Bytes+resourceLookupData _obj path lookup_flags = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    path' <- textToCString path+    let lookup_flags' = gflagsToWord lookup_flags+    onException (do+        result <- propagateGError $ g_resource_lookup_data _obj' path' lookup_flags'+        checkUnexpectedReturnNULL "g_resource_lookup_data" result+        result' <- (wrapBoxed GLib.Bytes) result+        touchManagedPtr _obj+        freeMem path'+        return result'+     ) (do+        freeMem path'+     )++-- method Resource::open_stream+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Resource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "lookup_flags", argType = TInterface "Gio" "ResourceLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Resource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "lookup_flags", argType = TInterface "Gio" "ResourceLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "InputStream"+-- throws : True+-- Skip return : False++foreign import ccall "g_resource_open_stream" g_resource_open_stream :: +    Ptr Resource ->                         -- _obj : TInterface "Gio" "Resource"+    CString ->                              -- path : TBasicType TUTF8+    CUInt ->                                -- lookup_flags : TInterface "Gio" "ResourceLookupFlags"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr InputStream)+++resourceOpenStream ::+    (MonadIO m) =>+    Resource ->                             -- _obj+    T.Text ->                               -- path+    [ResourceLookupFlags] ->                -- lookup_flags+    m InputStream+resourceOpenStream _obj path lookup_flags = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    path' <- textToCString path+    let lookup_flags' = gflagsToWord lookup_flags+    onException (do+        result <- propagateGError $ g_resource_open_stream _obj' path' lookup_flags'+        checkUnexpectedReturnNULL "g_resource_open_stream" result+        result' <- (wrapObject InputStream) result+        touchManagedPtr _obj+        freeMem path'+        return result'+     ) (do+        freeMem path'+     )++-- method Resource::ref+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Resource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Resource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Resource"+-- throws : False+-- Skip return : False++foreign import ccall "g_resource_ref" g_resource_ref :: +    Ptr Resource ->                         -- _obj : TInterface "Gio" "Resource"+    IO (Ptr Resource)+++resourceRef ::+    (MonadIO m) =>+    Resource ->                             -- _obj+    m Resource+resourceRef _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_resource_ref _obj'+    checkUnexpectedReturnNULL "g_resource_ref" result+    result' <- (wrapBoxed Resource) result+    touchManagedPtr _obj+    return result'++-- method Resource::unref+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "Resource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "Resource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_resource_unref" g_resource_unref :: +    Ptr Resource ->                         -- _obj : TInterface "Gio" "Resource"+    IO ()+++resourceUnref ::+    (MonadIO m) =>+    Resource ->                             -- _obj+    m ()+resourceUnref _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    g_resource_unref _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Structs/Resource.hs-boot view
@@ -0,0 +1,11 @@+module GI.Gio.Structs.Resource where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Resource = Resource (ForeignPtr Resource)+instance BoxedObject Resource where
+ GI/Gio/Structs/SettingsBackend.hs view
@@ -0,0 +1,57 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++The #GSettingsBackend interface defines a generic interface for+non-strictly-typed data that is stored in a hierarchy. To implement+an alternative storage backend for #GSettings, you need to implement+the #GSettingsBackend interface and then make it implement the+extension point #G_SETTINGS_BACKEND_EXTENSION_POINT_NAME.++The interface defines methods for reading and writing values, a+method for determining if writing of certain values will fail+(lockdown) and a change notification mechanism.++The semantics of the interface are very precisely defined and+implementations must carefully adhere to the expectations of+callers that are documented on each of the interface methods.++Some of the GSettingsBackend functions accept or return a #GTree.+These trees always have strings as keys and #GVariant as values.+g_settings_backend_create_tree() is a convenience function to create+suitable trees.++The GSettingsBackend API is exported to allow third-party+implementations, but does not carry the same stability guarantees+as the public GIO API. For this reason, you have to define the+C preprocessor symbol %G_SETTINGS_ENABLE_BACKEND before including+`gio/gsettingsbackend.h`.+-}++module GI.Gio.Structs.SettingsBackend+    ( ++-- * Exported types+    SettingsBackend(..)                     ,+    noSettingsBackend                       ,+++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks++newtype SettingsBackend = SettingsBackend (ForeignPtr SettingsBackend)+noSettingsBackend :: Maybe SettingsBackend+noSettingsBackend = Nothing++
+ GI/Gio/Structs/SettingsBackend.hs-boot view
@@ -0,0 +1,10 @@+module GI.Gio.Structs.SettingsBackend where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype SettingsBackend = SettingsBackend (ForeignPtr SettingsBackend)
+ GI/Gio/Structs/SettingsSchema.hs view
@@ -0,0 +1,381 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++The #GSettingsSchemaSource and #GSettingsSchema APIs provide a+mechanism for advanced control over the loading of schemas and a+mechanism for introspecting their content.++Plugin loading systems that wish to provide plugins a way to access+settings face the problem of how to make the schemas for these+settings visible to GSettings.  Typically, a plugin will want to ship+the schema along with itself and it won't be installed into the+standard system directories for schemas.++#GSettingsSchemaSource provides a mechanism for dealing with this by+allowing the creation of a new 'schema source' from which schemas can+be acquired.  This schema source can then become part of the metadata+associated with the plugin and queried whenever the plugin requires+access to some settings.++Consider the following example:++|[<!-- language="C" -->+typedef struct+{+   ...+   GSettingsSchemaSource *schema_source;+   ...+} Plugin;++Plugin *+initialise_plugin (const gchar *dir)+{+  Plugin *plugin;++  ...++  plugin->schema_source =+    g_settings_new_schema_source_from_directory (dir,+      g_settings_schema_source_get_default (), FALSE, NULL);++  ...++  return plugin;+}++...++GSettings *+plugin_get_settings (Plugin      *plugin,+                     const gchar *schema_id)+{+  GSettingsSchema *schema;++  if (schema_id == NULL)+    schema_id = plugin->identifier;++  schema = g_settings_schema_source_lookup (plugin->schema_source,+                                            schema_id, FALSE);++  if (schema == NULL)+    {+      ... disable the plugin or abort, etc ...+    }++  return g_settings_new_full (schema, NULL, NULL);+}+]|++The code above shows how hooks should be added to the code that+initialises (or enables) the plugin to create the schema source and+how an API can be added to the plugin system to provide a convenient+way for the plugin to access its settings, using the schemas that it+ships.++From the standpoint of the plugin, it would need to ensure that it+ships a gschemas.compiled file as part of itself, and then simply do+the following:++|[<!-- language="C" -->+{+  GSettings *settings;+  gint some_value;++  settings = plugin_get_settings (self, NULL);+  some_value = g_settings_get_int (settings, "some-value");+  ...+}+]|++It's also possible that the plugin system expects the schema source+files (ie: .gschema.xml files) instead of a gschemas.compiled file.+In that case, the plugin loading system must compile the schemas for+itself before attempting to create the settings source.+-}++module GI.Gio.Structs.SettingsSchema+    ( ++-- * Exported types+    SettingsSchema(..)                      ,+    noSettingsSchema                        ,+++ -- * Methods+-- ** settingsSchemaGetId+    settingsSchemaGetId                     ,+++-- ** settingsSchemaGetKey+    settingsSchemaGetKey                    ,+++-- ** settingsSchemaGetPath+    settingsSchemaGetPath                   ,+++-- ** settingsSchemaHasKey+    settingsSchemaHasKey                    ,+++-- ** settingsSchemaListChildren+    settingsSchemaListChildren              ,+++-- ** settingsSchemaListKeys+    settingsSchemaListKeys                  ,+++-- ** settingsSchemaRef+    settingsSchemaRef                       ,+++-- ** settingsSchemaUnref+    settingsSchemaUnref                     ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks++newtype SettingsSchema = SettingsSchema (ForeignPtr SettingsSchema)+foreign import ccall "g_settings_schema_get_type" c_g_settings_schema_get_type :: +    IO GType++instance BoxedObject SettingsSchema where+    boxedType _ = c_g_settings_schema_get_type++noSettingsSchema :: Maybe SettingsSchema+noSettingsSchema = Nothing++-- method SettingsSchema::get_id+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchema", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchema", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_schema_get_id" g_settings_schema_get_id :: +    Ptr SettingsSchema ->                   -- _obj : TInterface "Gio" "SettingsSchema"+    IO CString+++settingsSchemaGetId ::+    (MonadIO m) =>+    SettingsSchema ->                       -- _obj+    m T.Text+settingsSchemaGetId _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_settings_schema_get_id _obj'+    checkUnexpectedReturnNULL "g_settings_schema_get_id" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method SettingsSchema::get_key+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchema", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchema", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SettingsSchemaKey"+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_schema_get_key" g_settings_schema_get_key :: +    Ptr SettingsSchema ->                   -- _obj : TInterface "Gio" "SettingsSchema"+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr SettingsSchemaKey)+++settingsSchemaGetKey ::+    (MonadIO m) =>+    SettingsSchema ->                       -- _obj+    T.Text ->                               -- name+    m SettingsSchemaKey+settingsSchemaGetKey _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    name' <- textToCString name+    result <- g_settings_schema_get_key _obj' name'+    checkUnexpectedReturnNULL "g_settings_schema_get_key" result+    result' <- (wrapBoxed SettingsSchemaKey) result+    touchManagedPtr _obj+    freeMem name'+    return result'++-- method SettingsSchema::get_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchema", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchema", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_schema_get_path" g_settings_schema_get_path :: +    Ptr SettingsSchema ->                   -- _obj : TInterface "Gio" "SettingsSchema"+    IO CString+++settingsSchemaGetPath ::+    (MonadIO m) =>+    SettingsSchema ->                       -- _obj+    m T.Text+settingsSchemaGetPath _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_settings_schema_get_path _obj'+    checkUnexpectedReturnNULL "g_settings_schema_get_path" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method SettingsSchema::has_key+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchema", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchema", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_schema_has_key" g_settings_schema_has_key :: +    Ptr SettingsSchema ->                   -- _obj : TInterface "Gio" "SettingsSchema"+    CString ->                              -- name : TBasicType TUTF8+    IO CInt+++settingsSchemaHasKey ::+    (MonadIO m) =>+    SettingsSchema ->                       -- _obj+    T.Text ->                               -- name+    m Bool+settingsSchemaHasKey _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    name' <- textToCString name+    result <- g_settings_schema_has_key _obj' name'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem name'+    return result'++-- method SettingsSchema::list_children+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchema", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchema", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_schema_list_children" g_settings_schema_list_children :: +    Ptr SettingsSchema ->                   -- _obj : TInterface "Gio" "SettingsSchema"+    IO (Ptr CString)+++settingsSchemaListChildren ::+    (MonadIO m) =>+    SettingsSchema ->                       -- _obj+    m [T.Text]+settingsSchemaListChildren _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_settings_schema_list_children _obj'+    checkUnexpectedReturnNULL "g_settings_schema_list_children" result+    result' <- unpackZeroTerminatedUTF8CArray result+    mapZeroTerminatedCArray freeMem result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method SettingsSchema::list_keys+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchema", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchema", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_schema_list_keys" g_settings_schema_list_keys :: +    Ptr SettingsSchema ->                   -- _obj : TInterface "Gio" "SettingsSchema"+    IO (Ptr CString)+++settingsSchemaListKeys ::+    (MonadIO m) =>+    SettingsSchema ->                       -- _obj+    m [T.Text]+settingsSchemaListKeys _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_settings_schema_list_keys _obj'+    checkUnexpectedReturnNULL "g_settings_schema_list_keys" result+    result' <- unpackZeroTerminatedUTF8CArray result+    mapZeroTerminatedCArray freeMem result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method SettingsSchema::ref+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchema", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchema", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SettingsSchema"+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_schema_ref" g_settings_schema_ref :: +    Ptr SettingsSchema ->                   -- _obj : TInterface "Gio" "SettingsSchema"+    IO (Ptr SettingsSchema)+++settingsSchemaRef ::+    (MonadIO m) =>+    SettingsSchema ->                       -- _obj+    m SettingsSchema+settingsSchemaRef _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_settings_schema_ref _obj'+    checkUnexpectedReturnNULL "g_settings_schema_ref" result+    result' <- (wrapBoxed SettingsSchema) result+    touchManagedPtr _obj+    return result'++-- method SettingsSchema::unref+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchema", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchema", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_schema_unref" g_settings_schema_unref :: +    Ptr SettingsSchema ->                   -- _obj : TInterface "Gio" "SettingsSchema"+    IO ()+++settingsSchemaUnref ::+    (MonadIO m) =>+    SettingsSchema ->                       -- _obj+    m ()+settingsSchemaUnref _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    g_settings_schema_unref _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Structs/SettingsSchema.hs-boot view
@@ -0,0 +1,11 @@+module GI.Gio.Structs.SettingsSchema where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype SettingsSchema = SettingsSchema (ForeignPtr SettingsSchema)+instance BoxedObject SettingsSchema where
+ GI/Gio/Structs/SettingsSchemaKey.hs view
@@ -0,0 +1,315 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++#GSettingsSchemaKey is an opaque data structure and can only be accessed+using the following functions.+-}++module GI.Gio.Structs.SettingsSchemaKey+    ( ++-- * Exported types+    SettingsSchemaKey(..)                   ,+    noSettingsSchemaKey                     ,+++ -- * Methods+-- ** settingsSchemaKeyGetDefaultValue+    settingsSchemaKeyGetDefaultValue        ,+++-- ** settingsSchemaKeyGetDescription+    settingsSchemaKeyGetDescription         ,+++-- ** settingsSchemaKeyGetName+    settingsSchemaKeyGetName                ,+++-- ** settingsSchemaKeyGetRange+    settingsSchemaKeyGetRange               ,+++-- ** settingsSchemaKeyGetSummary+    settingsSchemaKeyGetSummary             ,+++-- ** settingsSchemaKeyGetValueType+    settingsSchemaKeyGetValueType           ,+++-- ** settingsSchemaKeyRangeCheck+    settingsSchemaKeyRangeCheck             ,+++-- ** settingsSchemaKeyRef+    settingsSchemaKeyRef                    ,+++-- ** settingsSchemaKeyUnref+    settingsSchemaKeyUnref                  ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks+import qualified GI.GLib as GLib++newtype SettingsSchemaKey = SettingsSchemaKey (ForeignPtr SettingsSchemaKey)+foreign import ccall "g_settings_schema_key_get_type" c_g_settings_schema_key_get_type :: +    IO GType++instance BoxedObject SettingsSchemaKey where+    boxedType _ = c_g_settings_schema_key_get_type++noSettingsSchemaKey :: Maybe SettingsSchemaKey+noSettingsSchemaKey = Nothing++-- method SettingsSchemaKey::get_default_value+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchemaKey", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchemaKey", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TVariant+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_schema_key_get_default_value" g_settings_schema_key_get_default_value :: +    Ptr SettingsSchemaKey ->                -- _obj : TInterface "Gio" "SettingsSchemaKey"+    IO (Ptr GVariant)+++settingsSchemaKeyGetDefaultValue ::+    (MonadIO m) =>+    SettingsSchemaKey ->                    -- _obj+    m GVariant+settingsSchemaKeyGetDefaultValue _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_settings_schema_key_get_default_value _obj'+    checkUnexpectedReturnNULL "g_settings_schema_key_get_default_value" result+    result' <- wrapGVariantPtr result+    touchManagedPtr _obj+    return result'++-- method SettingsSchemaKey::get_description+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchemaKey", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchemaKey", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_schema_key_get_description" g_settings_schema_key_get_description :: +    Ptr SettingsSchemaKey ->                -- _obj : TInterface "Gio" "SettingsSchemaKey"+    IO CString+++settingsSchemaKeyGetDescription ::+    (MonadIO m) =>+    SettingsSchemaKey ->                    -- _obj+    m T.Text+settingsSchemaKeyGetDescription _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_settings_schema_key_get_description _obj'+    checkUnexpectedReturnNULL "g_settings_schema_key_get_description" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method SettingsSchemaKey::get_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchemaKey", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchemaKey", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_schema_key_get_name" g_settings_schema_key_get_name :: +    Ptr SettingsSchemaKey ->                -- _obj : TInterface "Gio" "SettingsSchemaKey"+    IO CString+++settingsSchemaKeyGetName ::+    (MonadIO m) =>+    SettingsSchemaKey ->                    -- _obj+    m T.Text+settingsSchemaKeyGetName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_settings_schema_key_get_name _obj'+    checkUnexpectedReturnNULL "g_settings_schema_key_get_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method SettingsSchemaKey::get_range+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchemaKey", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchemaKey", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TVariant+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_schema_key_get_range" g_settings_schema_key_get_range :: +    Ptr SettingsSchemaKey ->                -- _obj : TInterface "Gio" "SettingsSchemaKey"+    IO (Ptr GVariant)+++settingsSchemaKeyGetRange ::+    (MonadIO m) =>+    SettingsSchemaKey ->                    -- _obj+    m GVariant+settingsSchemaKeyGetRange _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_settings_schema_key_get_range _obj'+    checkUnexpectedReturnNULL "g_settings_schema_key_get_range" result+    result' <- wrapGVariantPtr result+    touchManagedPtr _obj+    return result'++-- method SettingsSchemaKey::get_summary+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchemaKey", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchemaKey", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_schema_key_get_summary" g_settings_schema_key_get_summary :: +    Ptr SettingsSchemaKey ->                -- _obj : TInterface "Gio" "SettingsSchemaKey"+    IO CString+++settingsSchemaKeyGetSummary ::+    (MonadIO m) =>+    SettingsSchemaKey ->                    -- _obj+    m T.Text+settingsSchemaKeyGetSummary _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_settings_schema_key_get_summary _obj'+    checkUnexpectedReturnNULL "g_settings_schema_key_get_summary" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method SettingsSchemaKey::get_value_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchemaKey", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchemaKey", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GLib" "VariantType"+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_schema_key_get_value_type" g_settings_schema_key_get_value_type :: +    Ptr SettingsSchemaKey ->                -- _obj : TInterface "Gio" "SettingsSchemaKey"+    IO (Ptr GLib.VariantType)+++settingsSchemaKeyGetValueType ::+    (MonadIO m) =>+    SettingsSchemaKey ->                    -- _obj+    m GLib.VariantType+settingsSchemaKeyGetValueType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_settings_schema_key_get_value_type _obj'+    checkUnexpectedReturnNULL "g_settings_schema_key_get_value_type" result+    result' <- (newBoxed GLib.VariantType) result+    touchManagedPtr _obj+    return result'++-- method SettingsSchemaKey::range_check+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchemaKey", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TVariant, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchemaKey", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TVariant, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_schema_key_range_check" g_settings_schema_key_range_check :: +    Ptr SettingsSchemaKey ->                -- _obj : TInterface "Gio" "SettingsSchemaKey"+    Ptr GVariant ->                         -- value : TVariant+    IO CInt+++settingsSchemaKeyRangeCheck ::+    (MonadIO m) =>+    SettingsSchemaKey ->                    -- _obj+    GVariant ->                             -- value+    m Bool+settingsSchemaKeyRangeCheck _obj value = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let value' = unsafeManagedPtrGetPtr value+    result <- g_settings_schema_key_range_check _obj' value'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method SettingsSchemaKey::ref+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchemaKey", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchemaKey", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SettingsSchemaKey"+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_schema_key_ref" g_settings_schema_key_ref :: +    Ptr SettingsSchemaKey ->                -- _obj : TInterface "Gio" "SettingsSchemaKey"+    IO (Ptr SettingsSchemaKey)+++settingsSchemaKeyRef ::+    (MonadIO m) =>+    SettingsSchemaKey ->                    -- _obj+    m SettingsSchemaKey+settingsSchemaKeyRef _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_settings_schema_key_ref _obj'+    checkUnexpectedReturnNULL "g_settings_schema_key_ref" result+    result' <- (wrapBoxed SettingsSchemaKey) result+    touchManagedPtr _obj+    return result'++-- method SettingsSchemaKey::unref+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchemaKey", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchemaKey", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_schema_key_unref" g_settings_schema_key_unref :: +    Ptr SettingsSchemaKey ->                -- _obj : TInterface "Gio" "SettingsSchemaKey"+    IO ()+++settingsSchemaKeyUnref ::+    (MonadIO m) =>+    SettingsSchemaKey ->                    -- _obj+    m ()+settingsSchemaKeyUnref _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    g_settings_schema_key_unref _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Structs/SettingsSchemaKey.hs-boot view
@@ -0,0 +1,11 @@+module GI.Gio.Structs.SettingsSchemaKey where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype SettingsSchemaKey = SettingsSchemaKey (ForeignPtr SettingsSchemaKey)+instance BoxedObject SettingsSchemaKey where
+ GI/Gio/Structs/SettingsSchemaSource.hs view
@@ -0,0 +1,229 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++This is an opaque structure type.  You may not access it directly.+-}++module GI.Gio.Structs.SettingsSchemaSource+    ( ++-- * Exported types+    SettingsSchemaSource(..)                ,+    noSettingsSchemaSource                  ,+++ -- * Methods+-- ** settingsSchemaSourceListSchemas+    settingsSchemaSourceListSchemas         ,+++-- ** settingsSchemaSourceLookup+    settingsSchemaSourceLookup              ,+++-- ** settingsSchemaSourceNewFromDirectory+    settingsSchemaSourceNewFromDirectory    ,+++-- ** settingsSchemaSourceRef+    settingsSchemaSourceRef                 ,+++-- ** settingsSchemaSourceUnref+    settingsSchemaSourceUnref               ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks++newtype SettingsSchemaSource = SettingsSchemaSource (ForeignPtr SettingsSchemaSource)+foreign import ccall "g_settings_schema_source_get_type" c_g_settings_schema_source_get_type :: +    IO GType++instance BoxedObject SettingsSchemaSource where+    boxedType _ = c_g_settings_schema_source_get_type++noSettingsSchemaSource :: Maybe SettingsSchemaSource+noSettingsSchemaSource = Nothing++-- method SettingsSchemaSource::new_from_directory+-- method type : Constructor+-- Args : [Arg {argName = "directory", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parent", argType = TInterface "Gio" "SettingsSchemaSource", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "trusted", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "directory", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parent", argType = TInterface "Gio" "SettingsSchemaSource", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "trusted", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SettingsSchemaSource"+-- throws : True+-- Skip return : False++foreign import ccall "g_settings_schema_source_new_from_directory" g_settings_schema_source_new_from_directory :: +    CString ->                              -- directory : TBasicType TUTF8+    Ptr SettingsSchemaSource ->             -- parent : TInterface "Gio" "SettingsSchemaSource"+    CInt ->                                 -- trusted : TBasicType TBoolean+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr SettingsSchemaSource)+++settingsSchemaSourceNewFromDirectory ::+    (MonadIO m) =>+    T.Text ->                               -- directory+    Maybe (SettingsSchemaSource) ->         -- parent+    Bool ->                                 -- trusted+    m SettingsSchemaSource+settingsSchemaSourceNewFromDirectory directory parent trusted = liftIO $ do+    directory' <- textToCString directory+    maybeParent <- case parent of+        Nothing -> return nullPtr+        Just jParent -> do+            let jParent' = unsafeManagedPtrGetPtr jParent+            return jParent'+    let trusted' = (fromIntegral . fromEnum) trusted+    onException (do+        result <- propagateGError $ g_settings_schema_source_new_from_directory directory' maybeParent trusted'+        checkUnexpectedReturnNULL "g_settings_schema_source_new_from_directory" result+        result' <- (wrapBoxed SettingsSchemaSource) result+        whenJust parent touchManagedPtr+        freeMem directory'+        return result'+     ) (do+        freeMem directory'+     )++-- method SettingsSchemaSource::list_schemas+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchemaSource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "recursive", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "non_relocatable", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "relocatable", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchemaSource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "recursive", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_schema_source_list_schemas" g_settings_schema_source_list_schemas :: +    Ptr SettingsSchemaSource ->             -- _obj : TInterface "Gio" "SettingsSchemaSource"+    CInt ->                                 -- recursive : TBasicType TBoolean+    Ptr (Ptr CString) ->                    -- non_relocatable : TCArray True (-1) (-1) (TBasicType TUTF8)+    Ptr (Ptr CString) ->                    -- relocatable : TCArray True (-1) (-1) (TBasicType TUTF8)+    IO ()+++settingsSchemaSourceListSchemas ::+    (MonadIO m) =>+    SettingsSchemaSource ->                 -- _obj+    Bool ->                                 -- recursive+    m ([T.Text],[T.Text])+settingsSchemaSourceListSchemas _obj recursive = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let recursive' = (fromIntegral . fromEnum) recursive+    non_relocatable <- allocMem :: IO (Ptr (Ptr CString))+    relocatable <- allocMem :: IO (Ptr (Ptr CString))+    g_settings_schema_source_list_schemas _obj' recursive' non_relocatable relocatable+    non_relocatable' <- peek non_relocatable+    non_relocatable'' <- unpackZeroTerminatedUTF8CArray non_relocatable'+    mapZeroTerminatedCArray freeMem non_relocatable'+    freeMem non_relocatable'+    relocatable' <- peek relocatable+    relocatable'' <- unpackZeroTerminatedUTF8CArray relocatable'+    mapZeroTerminatedCArray freeMem relocatable'+    freeMem relocatable'+    touchManagedPtr _obj+    freeMem non_relocatable+    freeMem relocatable+    return (non_relocatable'', relocatable'')++-- method SettingsSchemaSource::lookup+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchemaSource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "schema_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "recursive", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchemaSource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "schema_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "recursive", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SettingsSchema"+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_schema_source_lookup" g_settings_schema_source_lookup :: +    Ptr SettingsSchemaSource ->             -- _obj : TInterface "Gio" "SettingsSchemaSource"+    CString ->                              -- schema_id : TBasicType TUTF8+    CInt ->                                 -- recursive : TBasicType TBoolean+    IO (Ptr SettingsSchema)+++settingsSchemaSourceLookup ::+    (MonadIO m) =>+    SettingsSchemaSource ->                 -- _obj+    T.Text ->                               -- schema_id+    Bool ->                                 -- recursive+    m SettingsSchema+settingsSchemaSourceLookup _obj schema_id recursive = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    schema_id' <- textToCString schema_id+    let recursive' = (fromIntegral . fromEnum) recursive+    result <- g_settings_schema_source_lookup _obj' schema_id' recursive'+    checkUnexpectedReturnNULL "g_settings_schema_source_lookup" result+    result' <- (wrapBoxed SettingsSchema) result+    touchManagedPtr _obj+    freeMem schema_id'+    return result'++-- method SettingsSchemaSource::ref+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchemaSource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchemaSource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SettingsSchemaSource"+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_schema_source_ref" g_settings_schema_source_ref :: +    Ptr SettingsSchemaSource ->             -- _obj : TInterface "Gio" "SettingsSchemaSource"+    IO (Ptr SettingsSchemaSource)+++settingsSchemaSourceRef ::+    (MonadIO m) =>+    SettingsSchemaSource ->                 -- _obj+    m SettingsSchemaSource+settingsSchemaSourceRef _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_settings_schema_source_ref _obj'+    checkUnexpectedReturnNULL "g_settings_schema_source_ref" result+    result' <- (wrapBoxed SettingsSchemaSource) result+    touchManagedPtr _obj+    return result'++-- method SettingsSchemaSource::unref+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchemaSource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SettingsSchemaSource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_settings_schema_source_unref" g_settings_schema_source_unref :: +    Ptr SettingsSchemaSource ->             -- _obj : TInterface "Gio" "SettingsSchemaSource"+    IO ()+++settingsSchemaSourceUnref ::+    (MonadIO m) =>+    SettingsSchemaSource ->                 -- _obj+    m ()+settingsSchemaSourceUnref _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    g_settings_schema_source_unref _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Structs/SettingsSchemaSource.hs-boot view
@@ -0,0 +1,11 @@+module GI.Gio.Structs.SettingsSchemaSource where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype SettingsSchemaSource = SettingsSchemaSource (ForeignPtr SettingsSchemaSource)+instance BoxedObject SettingsSchemaSource where
+ GI/Gio/Structs/SrvTarget.hs view
@@ -0,0 +1,264 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++SRV (service) records are used by some network protocols to provide+service-specific aliasing and load-balancing. For example, XMPP+(Jabber) uses SRV records to locate the XMPP server for a domain;+rather than connecting directly to "example.com" or assuming a+specific server hostname like "xmpp.example.com", an XMPP client+would look up the "xmpp-client" SRV record for "example.com", and+then connect to whatever host was pointed to by that record.++You can use g_resolver_lookup_service() or+g_resolver_lookup_service_async() to find the #GSrvTargets+for a given service. However, if you are simply planning to connect+to the remote service, you can use #GNetworkService's+#GSocketConnectable interface and not need to worry about+#GSrvTarget at all.+-}++module GI.Gio.Structs.SrvTarget+    ( ++-- * Exported types+    SrvTarget(..)                           ,+    noSrvTarget                             ,+++ -- * Methods+-- ** srvTargetCopy+    srvTargetCopy                           ,+++-- ** srvTargetFree+    srvTargetFree                           ,+++-- ** srvTargetGetHostname+    srvTargetGetHostname                    ,+++-- ** srvTargetGetPort+    srvTargetGetPort                        ,+++-- ** srvTargetGetPriority+    srvTargetGetPriority                    ,+++-- ** srvTargetGetWeight+    srvTargetGetWeight                      ,+++-- ** srvTargetNew+    srvTargetNew                            ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks++newtype SrvTarget = SrvTarget (ForeignPtr SrvTarget)+foreign import ccall "g_srv_target_get_type" c_g_srv_target_get_type :: +    IO GType++instance BoxedObject SrvTarget where+    boxedType _ = c_g_srv_target_get_type++noSrvTarget :: Maybe SrvTarget+noSrvTarget = Nothing++-- method SrvTarget::new+-- method type : Constructor+-- Args : [Arg {argName = "hostname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "port", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "priority", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "weight", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "hostname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "port", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "priority", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "weight", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SrvTarget"+-- throws : False+-- Skip return : False++foreign import ccall "g_srv_target_new" g_srv_target_new :: +    CString ->                              -- hostname : TBasicType TUTF8+    Word16 ->                               -- port : TBasicType TUInt16+    Word16 ->                               -- priority : TBasicType TUInt16+    Word16 ->                               -- weight : TBasicType TUInt16+    IO (Ptr SrvTarget)+++srvTargetNew ::+    (MonadIO m) =>+    T.Text ->                               -- hostname+    Word16 ->                               -- port+    Word16 ->                               -- priority+    Word16 ->                               -- weight+    m SrvTarget+srvTargetNew hostname port priority weight = liftIO $ do+    hostname' <- textToCString hostname+    result <- g_srv_target_new hostname' port priority weight+    checkUnexpectedReturnNULL "g_srv_target_new" result+    result' <- (wrapBoxed SrvTarget) result+    freeMem hostname'+    return result'++-- method SrvTarget::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SrvTarget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SrvTarget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "SrvTarget"+-- throws : False+-- Skip return : False++foreign import ccall "g_srv_target_copy" g_srv_target_copy :: +    Ptr SrvTarget ->                        -- _obj : TInterface "Gio" "SrvTarget"+    IO (Ptr SrvTarget)+++srvTargetCopy ::+    (MonadIO m) =>+    SrvTarget ->                            -- _obj+    m SrvTarget+srvTargetCopy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_srv_target_copy _obj'+    checkUnexpectedReturnNULL "g_srv_target_copy" result+    result' <- (wrapBoxed SrvTarget) result+    touchManagedPtr _obj+    return result'++-- method SrvTarget::free+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SrvTarget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SrvTarget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_srv_target_free" g_srv_target_free :: +    Ptr SrvTarget ->                        -- _obj : TInterface "Gio" "SrvTarget"+    IO ()+++srvTargetFree ::+    (MonadIO m) =>+    SrvTarget ->                            -- _obj+    m ()+srvTargetFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    g_srv_target_free _obj'+    touchManagedPtr _obj+    return ()++-- method SrvTarget::get_hostname+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SrvTarget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SrvTarget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_srv_target_get_hostname" g_srv_target_get_hostname :: +    Ptr SrvTarget ->                        -- _obj : TInterface "Gio" "SrvTarget"+    IO CString+++srvTargetGetHostname ::+    (MonadIO m) =>+    SrvTarget ->                            -- _obj+    m T.Text+srvTargetGetHostname _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_srv_target_get_hostname _obj'+    checkUnexpectedReturnNULL "g_srv_target_get_hostname" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method SrvTarget::get_port+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SrvTarget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SrvTarget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt16+-- throws : False+-- Skip return : False++foreign import ccall "g_srv_target_get_port" g_srv_target_get_port :: +    Ptr SrvTarget ->                        -- _obj : TInterface "Gio" "SrvTarget"+    IO Word16+++srvTargetGetPort ::+    (MonadIO m) =>+    SrvTarget ->                            -- _obj+    m Word16+srvTargetGetPort _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_srv_target_get_port _obj'+    touchManagedPtr _obj+    return result++-- method SrvTarget::get_priority+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SrvTarget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SrvTarget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt16+-- throws : False+-- Skip return : False++foreign import ccall "g_srv_target_get_priority" g_srv_target_get_priority :: +    Ptr SrvTarget ->                        -- _obj : TInterface "Gio" "SrvTarget"+    IO Word16+++srvTargetGetPriority ::+    (MonadIO m) =>+    SrvTarget ->                            -- _obj+    m Word16+srvTargetGetPriority _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_srv_target_get_priority _obj'+    touchManagedPtr _obj+    return result++-- method SrvTarget::get_weight+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "SrvTarget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "SrvTarget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt16+-- throws : False+-- Skip return : False++foreign import ccall "g_srv_target_get_weight" g_srv_target_get_weight :: +    Ptr SrvTarget ->                        -- _obj : TInterface "Gio" "SrvTarget"+    IO Word16+++srvTargetGetWeight ::+    (MonadIO m) =>+    SrvTarget ->                            -- _obj+    m Word16+srvTargetGetWeight _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_srv_target_get_weight _obj'+    touchManagedPtr _obj+    return result++
+ GI/Gio/Structs/SrvTarget.hs-boot view
@@ -0,0 +1,11 @@+module GI.Gio.Structs.SrvTarget where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype SrvTarget = SrvTarget (ForeignPtr SrvTarget)+instance BoxedObject SrvTarget where
+ GI/Gio/Structs/StaticResource.hs view
@@ -0,0 +1,124 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++#GStaticResource is an opaque data structure and can only be accessed+using the following functions.+-}++module GI.Gio.Structs.StaticResource+    ( ++-- * Exported types+    StaticResource(..)                      ,+    noStaticResource                        ,+++ -- * Methods+-- ** staticResourceFini+    staticResourceFini                      ,+++-- ** staticResourceGetResource+    staticResourceGetResource               ,+++-- ** staticResourceInit+    staticResourceInit                      ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks++newtype StaticResource = StaticResource (ForeignPtr StaticResource)+noStaticResource :: Maybe StaticResource+noStaticResource = Nothing++-- method StaticResource::fini+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "StaticResource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "StaticResource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_static_resource_fini" g_static_resource_fini :: +    Ptr StaticResource ->                   -- _obj : TInterface "Gio" "StaticResource"+    IO ()+++staticResourceFini ::+    (MonadIO m) =>+    StaticResource ->                       -- _obj+    m ()+staticResourceFini _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    g_static_resource_fini _obj'+    touchManagedPtr _obj+    return ()++-- method StaticResource::get_resource+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "StaticResource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "StaticResource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Resource"+-- throws : False+-- Skip return : False++foreign import ccall "g_static_resource_get_resource" g_static_resource_get_resource :: +    Ptr StaticResource ->                   -- _obj : TInterface "Gio" "StaticResource"+    IO (Ptr Resource)+++staticResourceGetResource ::+    (MonadIO m) =>+    StaticResource ->                       -- _obj+    m Resource+staticResourceGetResource _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_static_resource_get_resource _obj'+    checkUnexpectedReturnNULL "g_static_resource_get_resource" result+    result' <- (newBoxed Resource) result+    touchManagedPtr _obj+    return result'++-- method StaticResource::init+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "StaticResource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "StaticResource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_static_resource_init" g_static_resource_init :: +    Ptr StaticResource ->                   -- _obj : TInterface "Gio" "StaticResource"+    IO ()+++staticResourceInit ::+    (MonadIO m) =>+    StaticResource ->                       -- _obj+    m ()+staticResourceInit _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    g_static_resource_init _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gio/Structs/StaticResource.hs-boot view
@@ -0,0 +1,10 @@+module GI.Gio.Structs.StaticResource where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype StaticResource = StaticResource (ForeignPtr StaticResource)
+ GI/Gio/Structs/UnixMountEntry.hs view
@@ -0,0 +1,35 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Defines a Unix mount entry (e.g. <filename>/media/cdrom</filename>).+This corresponds roughly to a mtab entry.+-}++module GI.Gio.Structs.UnixMountEntry+    ( ++-- * Exported types+    UnixMountEntry(..)                      ,+    noUnixMountEntry                        ,+++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks++newtype UnixMountEntry = UnixMountEntry (ForeignPtr UnixMountEntry)+noUnixMountEntry :: Maybe UnixMountEntry+noUnixMountEntry = Nothing++
+ GI/Gio/Structs/UnixMountEntry.hs-boot view
@@ -0,0 +1,10 @@+module GI.Gio.Structs.UnixMountEntry where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype UnixMountEntry = UnixMountEntry (ForeignPtr UnixMountEntry)
+ GI/Gio/Structs/UnixMountPoint.hs view
@@ -0,0 +1,425 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Defines a Unix mount point (e.g. <filename>/dev</filename>).+This corresponds roughly to a fstab entry.+-}++module GI.Gio.Structs.UnixMountPoint+    ( ++-- * Exported types+    UnixMountPoint(..)                      ,+    noUnixMountPoint                        ,+++ -- * Methods+-- ** unixMountPointCompare+    unixMountPointCompare                   ,+++-- ** unixMountPointFree+    unixMountPointFree                      ,+++-- ** unixMountPointGetDevicePath+    unixMountPointGetDevicePath             ,+++-- ** unixMountPointGetFsType+    unixMountPointGetFsType                 ,+++-- ** unixMountPointGetMountPath+    unixMountPointGetMountPath              ,+++-- ** unixMountPointGetOptions+    unixMountPointGetOptions                ,+++-- ** unixMountPointGuessCanEject+    unixMountPointGuessCanEject             ,+++-- ** unixMountPointGuessIcon+    unixMountPointGuessIcon                 ,+++-- ** unixMountPointGuessName+    unixMountPointGuessName                 ,+++-- ** unixMountPointGuessSymbolicIcon+    unixMountPointGuessSymbolicIcon         ,+++-- ** unixMountPointIsLoopback+    unixMountPointIsLoopback                ,+++-- ** unixMountPointIsReadonly+    unixMountPointIsReadonly                ,+++-- ** unixMountPointIsUserMountable+    unixMountPointIsUserMountable           ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Gio.Types+import GI.Gio.Callbacks++newtype UnixMountPoint = UnixMountPoint (ForeignPtr UnixMountPoint)+noUnixMountPoint :: Maybe UnixMountPoint+noUnixMountPoint = Nothing++-- method UnixMountPoint::compare+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixMountPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mount2", argType = TInterface "Gio" "UnixMountPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixMountPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mount2", argType = TInterface "Gio" "UnixMountPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_mount_point_compare" g_unix_mount_point_compare :: +    Ptr UnixMountPoint ->                   -- _obj : TInterface "Gio" "UnixMountPoint"+    Ptr UnixMountPoint ->                   -- mount2 : TInterface "Gio" "UnixMountPoint"+    IO Int32+++unixMountPointCompare ::+    (MonadIO m) =>+    UnixMountPoint ->                       -- _obj+    UnixMountPoint ->                       -- mount2+    m Int32+unixMountPointCompare _obj mount2 = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let mount2' = unsafeManagedPtrGetPtr mount2+    result <- g_unix_mount_point_compare _obj' mount2'+    touchManagedPtr _obj+    touchManagedPtr mount2+    return result++-- method UnixMountPoint::free+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixMountPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixMountPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_mount_point_free" g_unix_mount_point_free :: +    Ptr UnixMountPoint ->                   -- _obj : TInterface "Gio" "UnixMountPoint"+    IO ()+++unixMountPointFree ::+    (MonadIO m) =>+    UnixMountPoint ->                       -- _obj+    m ()+unixMountPointFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    g_unix_mount_point_free _obj'+    touchManagedPtr _obj+    return ()++-- method UnixMountPoint::get_device_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixMountPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixMountPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_mount_point_get_device_path" g_unix_mount_point_get_device_path :: +    Ptr UnixMountPoint ->                   -- _obj : TInterface "Gio" "UnixMountPoint"+    IO CString+++unixMountPointGetDevicePath ::+    (MonadIO m) =>+    UnixMountPoint ->                       -- _obj+    m T.Text+unixMountPointGetDevicePath _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_unix_mount_point_get_device_path _obj'+    checkUnexpectedReturnNULL "g_unix_mount_point_get_device_path" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method UnixMountPoint::get_fs_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixMountPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixMountPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_mount_point_get_fs_type" g_unix_mount_point_get_fs_type :: +    Ptr UnixMountPoint ->                   -- _obj : TInterface "Gio" "UnixMountPoint"+    IO CString+++unixMountPointGetFsType ::+    (MonadIO m) =>+    UnixMountPoint ->                       -- _obj+    m T.Text+unixMountPointGetFsType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_unix_mount_point_get_fs_type _obj'+    checkUnexpectedReturnNULL "g_unix_mount_point_get_fs_type" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method UnixMountPoint::get_mount_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixMountPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixMountPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_mount_point_get_mount_path" g_unix_mount_point_get_mount_path :: +    Ptr UnixMountPoint ->                   -- _obj : TInterface "Gio" "UnixMountPoint"+    IO CString+++unixMountPointGetMountPath ::+    (MonadIO m) =>+    UnixMountPoint ->                       -- _obj+    m T.Text+unixMountPointGetMountPath _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_unix_mount_point_get_mount_path _obj'+    checkUnexpectedReturnNULL "g_unix_mount_point_get_mount_path" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method UnixMountPoint::get_options+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixMountPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixMountPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_mount_point_get_options" g_unix_mount_point_get_options :: +    Ptr UnixMountPoint ->                   -- _obj : TInterface "Gio" "UnixMountPoint"+    IO CString+++unixMountPointGetOptions ::+    (MonadIO m) =>+    UnixMountPoint ->                       -- _obj+    m T.Text+unixMountPointGetOptions _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_unix_mount_point_get_options _obj'+    checkUnexpectedReturnNULL "g_unix_mount_point_get_options" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method UnixMountPoint::guess_can_eject+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixMountPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixMountPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_mount_point_guess_can_eject" g_unix_mount_point_guess_can_eject :: +    Ptr UnixMountPoint ->                   -- _obj : TInterface "Gio" "UnixMountPoint"+    IO CInt+++unixMountPointGuessCanEject ::+    (MonadIO m) =>+    UnixMountPoint ->                       -- _obj+    m Bool+unixMountPointGuessCanEject _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_unix_mount_point_guess_can_eject _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method UnixMountPoint::guess_icon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixMountPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixMountPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Icon"+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_mount_point_guess_icon" g_unix_mount_point_guess_icon :: +    Ptr UnixMountPoint ->                   -- _obj : TInterface "Gio" "UnixMountPoint"+    IO (Ptr Icon)+++unixMountPointGuessIcon ::+    (MonadIO m) =>+    UnixMountPoint ->                       -- _obj+    m Icon+unixMountPointGuessIcon _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_unix_mount_point_guess_icon _obj'+    checkUnexpectedReturnNULL "g_unix_mount_point_guess_icon" result+    result' <- (wrapObject Icon) result+    touchManagedPtr _obj+    return result'++-- method UnixMountPoint::guess_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixMountPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixMountPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_mount_point_guess_name" g_unix_mount_point_guess_name :: +    Ptr UnixMountPoint ->                   -- _obj : TInterface "Gio" "UnixMountPoint"+    IO CString+++unixMountPointGuessName ::+    (MonadIO m) =>+    UnixMountPoint ->                       -- _obj+    m T.Text+unixMountPointGuessName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_unix_mount_point_guess_name _obj'+    checkUnexpectedReturnNULL "g_unix_mount_point_guess_name" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method UnixMountPoint::guess_symbolic_icon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixMountPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixMountPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Icon"+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_mount_point_guess_symbolic_icon" g_unix_mount_point_guess_symbolic_icon :: +    Ptr UnixMountPoint ->                   -- _obj : TInterface "Gio" "UnixMountPoint"+    IO (Ptr Icon)+++unixMountPointGuessSymbolicIcon ::+    (MonadIO m) =>+    UnixMountPoint ->                       -- _obj+    m Icon+unixMountPointGuessSymbolicIcon _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_unix_mount_point_guess_symbolic_icon _obj'+    checkUnexpectedReturnNULL "g_unix_mount_point_guess_symbolic_icon" result+    result' <- (wrapObject Icon) result+    touchManagedPtr _obj+    return result'++-- method UnixMountPoint::is_loopback+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixMountPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixMountPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_mount_point_is_loopback" g_unix_mount_point_is_loopback :: +    Ptr UnixMountPoint ->                   -- _obj : TInterface "Gio" "UnixMountPoint"+    IO CInt+++unixMountPointIsLoopback ::+    (MonadIO m) =>+    UnixMountPoint ->                       -- _obj+    m Bool+unixMountPointIsLoopback _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_unix_mount_point_is_loopback _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method UnixMountPoint::is_readonly+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixMountPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixMountPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_mount_point_is_readonly" g_unix_mount_point_is_readonly :: +    Ptr UnixMountPoint ->                   -- _obj : TInterface "Gio" "UnixMountPoint"+    IO CInt+++unixMountPointIsReadonly ::+    (MonadIO m) =>+    UnixMountPoint ->                       -- _obj+    m Bool+unixMountPointIsReadonly _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_unix_mount_point_is_readonly _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method UnixMountPoint::is_user_mountable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixMountPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gio" "UnixMountPoint", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "g_unix_mount_point_is_user_mountable" g_unix_mount_point_is_user_mountable :: +    Ptr UnixMountPoint ->                   -- _obj : TInterface "Gio" "UnixMountPoint"+    IO CInt+++unixMountPointIsUserMountable ::+    (MonadIO m) =>+    UnixMountPoint ->                       -- _obj+    m Bool+unixMountPointIsUserMountable _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- g_unix_mount_point_is_user_mountable _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++
+ GI/Gio/Structs/UnixMountPoint.hs-boot view
@@ -0,0 +1,10 @@+module GI.Gio.Structs.UnixMountPoint where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype UnixMountPoint = UnixMountPoint (ForeignPtr UnixMountPoint)
+ GI/Gio/Types.hs view
@@ -0,0 +1,348 @@+module GI.Gio.Types+    (     module GI.Gio.Interfaces.Action         ,+    module GI.Gio.Interfaces.ActionGroup    ,+    module GI.Gio.Interfaces.ActionMap      ,+    module GI.Gio.Interfaces.AppInfo        ,+    module GI.Gio.Interfaces.AsyncInitable  ,+    module GI.Gio.Interfaces.AsyncResult    ,+    module GI.Gio.Interfaces.Converter      ,+    module GI.Gio.Interfaces.DBusInterface  ,+    module GI.Gio.Interfaces.DBusObject     ,+    module GI.Gio.Interfaces.DBusObjectManager,+    module GI.Gio.Interfaces.DesktopAppInfoLookup,+    module GI.Gio.Interfaces.Drive          ,+    module GI.Gio.Interfaces.File           ,+    module GI.Gio.Interfaces.FileDescriptorBased,+    module GI.Gio.Interfaces.Icon           ,+    module GI.Gio.Interfaces.Initable       ,+    module GI.Gio.Interfaces.ListModel      ,+    module GI.Gio.Interfaces.LoadableIcon   ,+    module GI.Gio.Interfaces.Mount          ,+    module GI.Gio.Interfaces.NetworkMonitor ,+    module GI.Gio.Interfaces.PollableInputStream,+    module GI.Gio.Interfaces.PollableOutputStream,+    module GI.Gio.Interfaces.Proxy          ,+    module GI.Gio.Interfaces.ProxyResolver  ,+    module GI.Gio.Interfaces.RemoteActionGroup,+    module GI.Gio.Interfaces.Seekable       ,+    module GI.Gio.Interfaces.SocketConnectable,+    module GI.Gio.Interfaces.TlsBackend     ,+    module GI.Gio.Interfaces.TlsClientConnection,+    module GI.Gio.Interfaces.TlsFileDatabase,+    module GI.Gio.Interfaces.TlsServerConnection,+    module GI.Gio.Interfaces.Volume         ,+    module GI.Gio.Objects.AppInfoMonitor    ,+    module GI.Gio.Objects.AppLaunchContext  ,+    module GI.Gio.Objects.Application       ,+    module GI.Gio.Objects.ApplicationCommandLine,+    module GI.Gio.Objects.BufferedInputStream,+    module GI.Gio.Objects.BufferedOutputStream,+    module GI.Gio.Objects.BytesIcon         ,+    module GI.Gio.Objects.Cancellable       ,+    module GI.Gio.Objects.CharsetConverter  ,+    module GI.Gio.Objects.ConverterInputStream,+    module GI.Gio.Objects.ConverterOutputStream,+    module GI.Gio.Objects.Credentials       ,+    module GI.Gio.Objects.DBusActionGroup   ,+    module GI.Gio.Objects.DBusAuthObserver  ,+    module GI.Gio.Objects.DBusConnection    ,+    module GI.Gio.Objects.DBusInterfaceSkeleton,+    module GI.Gio.Objects.DBusMenuModel     ,+    module GI.Gio.Objects.DBusMessage       ,+    module GI.Gio.Objects.DBusMethodInvocation,+    module GI.Gio.Objects.DBusObjectManagerClient,+    module GI.Gio.Objects.DBusObjectManagerServer,+    module GI.Gio.Objects.DBusObjectProxy   ,+    module GI.Gio.Objects.DBusObjectSkeleton,+    module GI.Gio.Objects.DBusProxy         ,+    module GI.Gio.Objects.DBusServer        ,+    module GI.Gio.Objects.DataInputStream   ,+    module GI.Gio.Objects.DataOutputStream  ,+    module GI.Gio.Objects.DesktopAppInfo    ,+    module GI.Gio.Objects.Emblem            ,+    module GI.Gio.Objects.EmblemedIcon      ,+    module GI.Gio.Objects.FileEnumerator    ,+    module GI.Gio.Objects.FileIOStream      ,+    module GI.Gio.Objects.FileIcon          ,+    module GI.Gio.Objects.FileInfo          ,+    module GI.Gio.Objects.FileInputStream   ,+    module GI.Gio.Objects.FileMonitor       ,+    module GI.Gio.Objects.FileOutputStream  ,+    module GI.Gio.Objects.FilenameCompleter ,+    module GI.Gio.Objects.FilterInputStream ,+    module GI.Gio.Objects.FilterOutputStream,+    module GI.Gio.Objects.IOStream          ,+    module GI.Gio.Objects.InetAddress       ,+    module GI.Gio.Objects.InetAddressMask   ,+    module GI.Gio.Objects.InetSocketAddress ,+    module GI.Gio.Objects.InputStream       ,+    module GI.Gio.Objects.ListStore         ,+    module GI.Gio.Objects.MemoryInputStream ,+    module GI.Gio.Objects.MemoryOutputStream,+    module GI.Gio.Objects.Menu              ,+    module GI.Gio.Objects.MenuAttributeIter ,+    module GI.Gio.Objects.MenuItem          ,+    module GI.Gio.Objects.MenuLinkIter      ,+    module GI.Gio.Objects.MenuModel         ,+    module GI.Gio.Objects.MountOperation    ,+    module GI.Gio.Objects.NativeVolumeMonitor,+    module GI.Gio.Objects.NetworkAddress    ,+    module GI.Gio.Objects.NetworkService    ,+    module GI.Gio.Objects.Notification      ,+    module GI.Gio.Objects.OutputStream      ,+    module GI.Gio.Objects.Permission        ,+    module GI.Gio.Objects.PropertyAction    ,+    module GI.Gio.Objects.ProxyAddress      ,+    module GI.Gio.Objects.ProxyAddressEnumerator,+    module GI.Gio.Objects.Resolver          ,+    module GI.Gio.Objects.Settings          ,+    module GI.Gio.Objects.SimpleAction      ,+    module GI.Gio.Objects.SimpleActionGroup ,+    module GI.Gio.Objects.SimpleAsyncResult ,+    module GI.Gio.Objects.SimpleIOStream    ,+    module GI.Gio.Objects.SimplePermission  ,+    module GI.Gio.Objects.SimpleProxyResolver,+    module GI.Gio.Objects.Socket            ,+    module GI.Gio.Objects.SocketAddress     ,+    module GI.Gio.Objects.SocketAddressEnumerator,+    module GI.Gio.Objects.SocketClient      ,+    module GI.Gio.Objects.SocketConnection  ,+    module GI.Gio.Objects.SocketControlMessage,+    module GI.Gio.Objects.SocketListener    ,+    module GI.Gio.Objects.SocketService     ,+    module GI.Gio.Objects.Subprocess        ,+    module GI.Gio.Objects.SubprocessLauncher,+    module GI.Gio.Objects.Task              ,+    module GI.Gio.Objects.TcpConnection     ,+    module GI.Gio.Objects.TcpWrapperConnection,+    module GI.Gio.Objects.TestDBus          ,+    module GI.Gio.Objects.ThemedIcon        ,+    module GI.Gio.Objects.ThreadedSocketService,+    module GI.Gio.Objects.TlsCertificate    ,+    module GI.Gio.Objects.TlsConnection     ,+    module GI.Gio.Objects.TlsDatabase       ,+    module GI.Gio.Objects.TlsInteraction    ,+    module GI.Gio.Objects.TlsPassword       ,+    module GI.Gio.Objects.UnixConnection    ,+    module GI.Gio.Objects.UnixCredentialsMessage,+    module GI.Gio.Objects.UnixFDList        ,+    module GI.Gio.Objects.UnixFDMessage     ,+    module GI.Gio.Objects.UnixInputStream   ,+    module GI.Gio.Objects.UnixMountMonitor  ,+    module GI.Gio.Objects.UnixOutputStream  ,+    module GI.Gio.Objects.UnixSocketAddress ,+    module GI.Gio.Objects.Vfs               ,+    module GI.Gio.Objects.VolumeMonitor     ,+    module GI.Gio.Objects.ZlibCompressor    ,+    module GI.Gio.Objects.ZlibDecompressor  ,+    module GI.Gio.Structs.ActionEntry       ,+    module GI.Gio.Structs.DBusAnnotationInfo,+    module GI.Gio.Structs.DBusArgInfo       ,+    module GI.Gio.Structs.DBusErrorEntry    ,+    module GI.Gio.Structs.DBusInterfaceInfo ,+    module GI.Gio.Structs.DBusInterfaceVTable,+    module GI.Gio.Structs.DBusMethodInfo    ,+    module GI.Gio.Structs.DBusNodeInfo      ,+    module GI.Gio.Structs.DBusPropertyInfo  ,+    module GI.Gio.Structs.DBusSignalInfo    ,+    module GI.Gio.Structs.DBusSubtreeVTable ,+    module GI.Gio.Structs.FileAttributeInfo ,+    module GI.Gio.Structs.FileAttributeInfoList,+    module GI.Gio.Structs.FileAttributeMatcher,+    module GI.Gio.Structs.IOExtension       ,+    module GI.Gio.Structs.IOExtensionPoint  ,+    module GI.Gio.Structs.IOModuleScope     ,+    module GI.Gio.Structs.IOSchedulerJob    ,+    module GI.Gio.Structs.IOStreamAdapter   ,+    module GI.Gio.Structs.InputVector       ,+    module GI.Gio.Structs.NativeSocketAddress,+    module GI.Gio.Structs.OutputMessage     ,+    module GI.Gio.Structs.OutputVector      ,+    module GI.Gio.Structs.Resource          ,+    module GI.Gio.Structs.SettingsBackend   ,+    module GI.Gio.Structs.SettingsSchema    ,+    module GI.Gio.Structs.SettingsSchemaKey ,+    module GI.Gio.Structs.SettingsSchemaSource,+    module GI.Gio.Structs.SrvTarget         ,+    module GI.Gio.Structs.StaticResource    ,+    module GI.Gio.Structs.UnixMountEntry    ,+    module GI.Gio.Structs.UnixMountPoint    ,+    module GI.Gio.Enums                     ,+    module GI.Gio.Flags                     ,+++    ) where+++import {-# SOURCE #-} GI.Gio.Interfaces.Action+import {-# SOURCE #-} GI.Gio.Interfaces.ActionGroup+import {-# SOURCE #-} GI.Gio.Interfaces.ActionMap+import {-# SOURCE #-} GI.Gio.Interfaces.AppInfo+import {-# SOURCE #-} GI.Gio.Interfaces.AsyncInitable+import {-# SOURCE #-} GI.Gio.Interfaces.AsyncResult+import {-# SOURCE #-} GI.Gio.Interfaces.Converter+import {-# SOURCE #-} GI.Gio.Interfaces.DBusInterface+import {-# SOURCE #-} GI.Gio.Interfaces.DBusObject+import {-# SOURCE #-} GI.Gio.Interfaces.DBusObjectManager+import {-# SOURCE #-} GI.Gio.Interfaces.DesktopAppInfoLookup+import {-# SOURCE #-} GI.Gio.Interfaces.Drive+import {-# SOURCE #-} GI.Gio.Interfaces.File+import {-# SOURCE #-} GI.Gio.Interfaces.FileDescriptorBased+import {-# SOURCE #-} GI.Gio.Interfaces.Icon+import {-# SOURCE #-} GI.Gio.Interfaces.Initable+import {-# SOURCE #-} GI.Gio.Interfaces.ListModel+import {-# SOURCE #-} GI.Gio.Interfaces.LoadableIcon+import {-# SOURCE #-} GI.Gio.Interfaces.Mount+import {-# SOURCE #-} GI.Gio.Interfaces.NetworkMonitor+import {-# SOURCE #-} GI.Gio.Interfaces.PollableInputStream+import {-# SOURCE #-} GI.Gio.Interfaces.PollableOutputStream+import {-# SOURCE #-} GI.Gio.Interfaces.Proxy+import {-# SOURCE #-} GI.Gio.Interfaces.ProxyResolver+import {-# SOURCE #-} GI.Gio.Interfaces.RemoteActionGroup+import {-# SOURCE #-} GI.Gio.Interfaces.Seekable+import {-# SOURCE #-} GI.Gio.Interfaces.SocketConnectable+import {-# SOURCE #-} GI.Gio.Interfaces.TlsBackend+import {-# SOURCE #-} GI.Gio.Interfaces.TlsClientConnection+import {-# SOURCE #-} GI.Gio.Interfaces.TlsFileDatabase+import {-# SOURCE #-} GI.Gio.Interfaces.TlsServerConnection+import {-# SOURCE #-} GI.Gio.Interfaces.Volume+import {-# SOURCE #-} GI.Gio.Objects.AppInfoMonitor+import {-# SOURCE #-} GI.Gio.Objects.AppLaunchContext+import {-# SOURCE #-} GI.Gio.Objects.Application+import {-# SOURCE #-} GI.Gio.Objects.ApplicationCommandLine+import {-# SOURCE #-} GI.Gio.Objects.BufferedInputStream+import {-# SOURCE #-} GI.Gio.Objects.BufferedOutputStream+import {-# SOURCE #-} GI.Gio.Objects.BytesIcon+import {-# SOURCE #-} GI.Gio.Objects.Cancellable+import {-# SOURCE #-} GI.Gio.Objects.CharsetConverter+import {-# SOURCE #-} GI.Gio.Objects.ConverterInputStream+import {-# SOURCE #-} GI.Gio.Objects.ConverterOutputStream+import {-# SOURCE #-} GI.Gio.Objects.Credentials+import {-# SOURCE #-} GI.Gio.Objects.DBusActionGroup+import {-# SOURCE #-} GI.Gio.Objects.DBusAuthObserver+import {-# SOURCE #-} GI.Gio.Objects.DBusConnection+import {-# SOURCE #-} GI.Gio.Objects.DBusInterfaceSkeleton+import {-# SOURCE #-} GI.Gio.Objects.DBusMenuModel+import {-# SOURCE #-} GI.Gio.Objects.DBusMessage+import {-# SOURCE #-} GI.Gio.Objects.DBusMethodInvocation+import {-# SOURCE #-} GI.Gio.Objects.DBusObjectManagerClient+import {-# SOURCE #-} GI.Gio.Objects.DBusObjectManagerServer+import {-# SOURCE #-} GI.Gio.Objects.DBusObjectProxy+import {-# SOURCE #-} GI.Gio.Objects.DBusObjectSkeleton+import {-# SOURCE #-} GI.Gio.Objects.DBusProxy+import {-# SOURCE #-} GI.Gio.Objects.DBusServer+import {-# SOURCE #-} GI.Gio.Objects.DataInputStream+import {-# SOURCE #-} GI.Gio.Objects.DataOutputStream+import {-# SOURCE #-} GI.Gio.Objects.DesktopAppInfo+import {-# SOURCE #-} GI.Gio.Objects.Emblem+import {-# SOURCE #-} GI.Gio.Objects.EmblemedIcon+import {-# SOURCE #-} GI.Gio.Objects.FileEnumerator+import {-# SOURCE #-} GI.Gio.Objects.FileIOStream+import {-# SOURCE #-} GI.Gio.Objects.FileIcon+import {-# SOURCE #-} GI.Gio.Objects.FileInfo+import {-# SOURCE #-} GI.Gio.Objects.FileInputStream+import {-# SOURCE #-} GI.Gio.Objects.FileMonitor+import {-# SOURCE #-} GI.Gio.Objects.FileOutputStream+import {-# SOURCE #-} GI.Gio.Objects.FilenameCompleter+import {-# SOURCE #-} GI.Gio.Objects.FilterInputStream+import {-# SOURCE #-} GI.Gio.Objects.FilterOutputStream+import {-# SOURCE #-} GI.Gio.Objects.IOStream+import {-# SOURCE #-} GI.Gio.Objects.InetAddress+import {-# SOURCE #-} GI.Gio.Objects.InetAddressMask+import {-# SOURCE #-} GI.Gio.Objects.InetSocketAddress+import {-# SOURCE #-} GI.Gio.Objects.InputStream+import {-# SOURCE #-} GI.Gio.Objects.ListStore+import {-# SOURCE #-} GI.Gio.Objects.MemoryInputStream+import {-# SOURCE #-} GI.Gio.Objects.MemoryOutputStream+import {-# SOURCE #-} GI.Gio.Objects.Menu+import {-# SOURCE #-} GI.Gio.Objects.MenuAttributeIter+import {-# SOURCE #-} GI.Gio.Objects.MenuItem+import {-# SOURCE #-} GI.Gio.Objects.MenuLinkIter+import {-# SOURCE #-} GI.Gio.Objects.MenuModel+import {-# SOURCE #-} GI.Gio.Objects.MountOperation+import {-# SOURCE #-} GI.Gio.Objects.NativeVolumeMonitor+import {-# SOURCE #-} GI.Gio.Objects.NetworkAddress+import {-# SOURCE #-} GI.Gio.Objects.NetworkService+import {-# SOURCE #-} GI.Gio.Objects.Notification+import {-# SOURCE #-} GI.Gio.Objects.OutputStream+import {-# SOURCE #-} GI.Gio.Objects.Permission+import {-# SOURCE #-} GI.Gio.Objects.PropertyAction+import {-# SOURCE #-} GI.Gio.Objects.ProxyAddress+import {-# SOURCE #-} GI.Gio.Objects.ProxyAddressEnumerator+import {-# SOURCE #-} GI.Gio.Objects.Resolver+import {-# SOURCE #-} GI.Gio.Objects.Settings+import {-# SOURCE #-} GI.Gio.Objects.SimpleAction+import {-# SOURCE #-} GI.Gio.Objects.SimpleActionGroup+import {-# SOURCE #-} GI.Gio.Objects.SimpleAsyncResult+import {-# SOURCE #-} GI.Gio.Objects.SimpleIOStream+import {-# SOURCE #-} GI.Gio.Objects.SimplePermission+import {-# SOURCE #-} GI.Gio.Objects.SimpleProxyResolver+import {-# SOURCE #-} GI.Gio.Objects.Socket+import {-# SOURCE #-} GI.Gio.Objects.SocketAddress+import {-# SOURCE #-} GI.Gio.Objects.SocketAddressEnumerator+import {-# SOURCE #-} GI.Gio.Objects.SocketClient+import {-# SOURCE #-} GI.Gio.Objects.SocketConnection+import {-# SOURCE #-} GI.Gio.Objects.SocketControlMessage+import {-# SOURCE #-} GI.Gio.Objects.SocketListener+import {-# SOURCE #-} GI.Gio.Objects.SocketService+import {-# SOURCE #-} GI.Gio.Objects.Subprocess+import {-# SOURCE #-} GI.Gio.Objects.SubprocessLauncher+import {-# SOURCE #-} GI.Gio.Objects.Task+import {-# SOURCE #-} GI.Gio.Objects.TcpConnection+import {-# SOURCE #-} GI.Gio.Objects.TcpWrapperConnection+import {-# SOURCE #-} GI.Gio.Objects.TestDBus+import {-# SOURCE #-} GI.Gio.Objects.ThemedIcon+import {-# SOURCE #-} GI.Gio.Objects.ThreadedSocketService+import {-# SOURCE #-} GI.Gio.Objects.TlsCertificate+import {-# SOURCE #-} GI.Gio.Objects.TlsConnection+import {-# SOURCE #-} GI.Gio.Objects.TlsDatabase+import {-# SOURCE #-} GI.Gio.Objects.TlsInteraction+import {-# SOURCE #-} GI.Gio.Objects.TlsPassword+import {-# SOURCE #-} GI.Gio.Objects.UnixConnection+import {-# SOURCE #-} GI.Gio.Objects.UnixCredentialsMessage+import {-# SOURCE #-} GI.Gio.Objects.UnixFDList+import {-# SOURCE #-} GI.Gio.Objects.UnixFDMessage+import {-# SOURCE #-} GI.Gio.Objects.UnixInputStream+import {-# SOURCE #-} GI.Gio.Objects.UnixMountMonitor+import {-# SOURCE #-} GI.Gio.Objects.UnixOutputStream+import {-# SOURCE #-} GI.Gio.Objects.UnixSocketAddress+import {-# SOURCE #-} GI.Gio.Objects.Vfs+import {-# SOURCE #-} GI.Gio.Objects.VolumeMonitor+import {-# SOURCE #-} GI.Gio.Objects.ZlibCompressor+import {-# SOURCE #-} GI.Gio.Objects.ZlibDecompressor+import {-# SOURCE #-} GI.Gio.Structs.ActionEntry+import {-# SOURCE #-} GI.Gio.Structs.DBusAnnotationInfo+import {-# SOURCE #-} GI.Gio.Structs.DBusArgInfo+import {-# SOURCE #-} GI.Gio.Structs.DBusErrorEntry+import {-# SOURCE #-} GI.Gio.Structs.DBusInterfaceInfo+import {-# SOURCE #-} GI.Gio.Structs.DBusInterfaceVTable+import {-# SOURCE #-} GI.Gio.Structs.DBusMethodInfo+import {-# SOURCE #-} GI.Gio.Structs.DBusNodeInfo+import {-# SOURCE #-} GI.Gio.Structs.DBusPropertyInfo+import {-# SOURCE #-} GI.Gio.Structs.DBusSignalInfo+import {-# SOURCE #-} GI.Gio.Structs.DBusSubtreeVTable+import {-# SOURCE #-} GI.Gio.Structs.FileAttributeInfo+import {-# SOURCE #-} GI.Gio.Structs.FileAttributeInfoList+import {-# SOURCE #-} GI.Gio.Structs.FileAttributeMatcher+import {-# SOURCE #-} GI.Gio.Structs.IOExtension+import {-# SOURCE #-} GI.Gio.Structs.IOExtensionPoint+import {-# SOURCE #-} GI.Gio.Structs.IOModuleScope+import {-# SOURCE #-} GI.Gio.Structs.IOSchedulerJob+import {-# SOURCE #-} GI.Gio.Structs.IOStreamAdapter+import {-# SOURCE #-} GI.Gio.Structs.InputVector+import {-# SOURCE #-} GI.Gio.Structs.NativeSocketAddress+import {-# SOURCE #-} GI.Gio.Structs.OutputMessage+import {-# SOURCE #-} GI.Gio.Structs.OutputVector+import {-# SOURCE #-} GI.Gio.Structs.Resource+import {-# SOURCE #-} GI.Gio.Structs.SettingsBackend+import {-# SOURCE #-} GI.Gio.Structs.SettingsSchema+import {-# SOURCE #-} GI.Gio.Structs.SettingsSchemaKey+import {-# SOURCE #-} GI.Gio.Structs.SettingsSchemaSource+import {-# SOURCE #-} GI.Gio.Structs.SrvTarget+import {-# SOURCE #-} GI.Gio.Structs.StaticResource+import {-# SOURCE #-} GI.Gio.Structs.UnixMountEntry+import {-# SOURCE #-} GI.Gio.Structs.UnixMountPoint++import GI.Gio.Enums+import GI.Gio.Flags+
− GI/GioAttributes.hs 
@@ -1,5298 +0,0 @@-{-# OPTIONS_GHC -fno-warn-orphans -fno-warn-unused-imports #-}---- Generated code.--{-# OPTIONS_GHC -fno-warn-unused-imports #-}--{-# LANGUAGE ForeignFunctionInterface, ConstraintKinds,-    TypeFamilies, MultiParamTypeClasses, KindSignatures,-    FlexibleInstances, UndecidableInstances, DataKinds,-    OverloadedStrings, NegativeLiterals, FlexibleContexts #-}--module GI.GioAttributes where--import Prelude ()-import Data.GI.Base.ShortPrelude-import Data.Char-import Data.Int-import Data.Word-import qualified Data.ByteString.Char8 as B-import Data.ByteString.Char8 (ByteString)-import qualified Data.Map as Map-import Foreign.C-import Foreign.Ptr-import Foreign.ForeignPtr-import Foreign.ForeignPtr.Unsafe (unsafeForeignPtrToPtr)-import Foreign.Storable (peek, poke, sizeOf)-import Control.Applicative ((<$>))-import Control.Exception (onException)-import Control.Monad.IO.Class-import qualified Data.Text as T--import Data.GI.Base.Attributes hiding (get, set)-import Data.GI.Base.BasicTypes-import Data.GI.Base.BasicConversions-import Data.GI.Base.Closure-import Data.GI.Base.GError-import Data.GI.Base.GHashTable-import Data.GI.Base.GParamSpec-import Data.GI.Base.GVariant-import Data.GI.Base.GValue-import Data.GI.Base.ManagedPtr-import Data.GI.Base.Overloading-import Data.GI.Base.Properties hiding (new)-import Data.GI.Base.Signals (SignalConnectMode(..), connectSignalFunPtr, SignalHandlerId)-import Data.GI.Base.Utils--import qualified GI.GLib as GLib-import qualified GI.GLibAttributes as GLibA-import qualified GI.GObject as GObject-import qualified GI.GObjectAttributes as GObjectA-import GI.Gio---- VVV Prop "enabled"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable]--getActionEnabled :: (MonadIO m, ActionK o) => o -> m Bool-getActionEnabled obj = liftIO $ getObjectPropertyBool obj "enabled"--data ActionEnabledPropertyInfo-instance AttrInfo ActionEnabledPropertyInfo where-    type AttrAllowedOps ActionEnabledPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint ActionEnabledPropertyInfo = (~) ()-    type AttrBaseTypeConstraint ActionEnabledPropertyInfo = ActionK-    type AttrGetType ActionEnabledPropertyInfo = Bool-    type AttrLabel ActionEnabledPropertyInfo = "Action::enabled"-    attrGet _ = getActionEnabled-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "name"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable]--getActionName :: (MonadIO m, ActionK o) => o -> m T.Text-getActionName obj = liftIO $ getObjectPropertyString obj "name"--data ActionNamePropertyInfo-instance AttrInfo ActionNamePropertyInfo where-    type AttrAllowedOps ActionNamePropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint ActionNamePropertyInfo = (~) ()-    type AttrBaseTypeConstraint ActionNamePropertyInfo = ActionK-    type AttrGetType ActionNamePropertyInfo = T.Text-    type AttrLabel ActionNamePropertyInfo = "Action::name"-    attrGet _ = getActionName-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "parameter-type"-   -- Type: TInterface "GLib" "VariantType"-   -- Flags: [PropertyReadable]--getActionParameterType :: (MonadIO m, ActionK o) => o -> m GLib.VariantType-getActionParameterType obj = liftIO $ getObjectPropertyBoxed obj "parameter-type" GLib.VariantType--data ActionParameterTypePropertyInfo-instance AttrInfo ActionParameterTypePropertyInfo where-    type AttrAllowedOps ActionParameterTypePropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint ActionParameterTypePropertyInfo = (~) ()-    type AttrBaseTypeConstraint ActionParameterTypePropertyInfo = ActionK-    type AttrGetType ActionParameterTypePropertyInfo = GLib.VariantType-    type AttrLabel ActionParameterTypePropertyInfo = "Action::parameter-type"-    attrGet _ = getActionParameterType-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "state"-   -- Type: TVariant-   -- Flags: [PropertyReadable]--getActionState :: (MonadIO m, ActionK o) => o -> m GVariant-getActionState obj = liftIO $ getObjectPropertyVariant obj "state"--data ActionStatePropertyInfo-instance AttrInfo ActionStatePropertyInfo where-    type AttrAllowedOps ActionStatePropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint ActionStatePropertyInfo = (~) ()-    type AttrBaseTypeConstraint ActionStatePropertyInfo = ActionK-    type AttrGetType ActionStatePropertyInfo = GVariant-    type AttrLabel ActionStatePropertyInfo = "Action::state"-    attrGet _ = getActionState-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "state-type"-   -- Type: TInterface "GLib" "VariantType"-   -- Flags: [PropertyReadable]--getActionStateType :: (MonadIO m, ActionK o) => o -> m GLib.VariantType-getActionStateType obj = liftIO $ getObjectPropertyBoxed obj "state-type" GLib.VariantType--data ActionStateTypePropertyInfo-instance AttrInfo ActionStateTypePropertyInfo where-    type AttrAllowedOps ActionStateTypePropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint ActionStateTypePropertyInfo = (~) ()-    type AttrBaseTypeConstraint ActionStateTypePropertyInfo = ActionK-    type AttrGetType ActionStateTypePropertyInfo = GLib.VariantType-    type AttrLabel ActionStateTypePropertyInfo = "Action::state-type"-    attrGet _ = getActionStateType-    attrSet _ = undefined-    attrConstruct _ = undefined--type instance AttributeList Action = '[ '("enabled", ActionEnabledPropertyInfo), '("name", ActionNamePropertyInfo), '("parameter-type", ActionParameterTypePropertyInfo), '("state", ActionStatePropertyInfo), '("state-type", ActionStateTypePropertyInfo)]--type instance AttributeList ActionGroup = '[ ]--type instance AttributeList ActionMap = '[ ]--type instance AttributeList AppInfo = '[ ]--type instance AttributeList AppInfoMonitor = '[ ]--type instance AttributeList AppLaunchContext = '[ ]---- VVV Prop "action-group"-   -- Type: TInterface "Gio" "ActionGroup"-   -- Flags: [PropertyWritable]--setApplicationActionGroup :: (MonadIO m, ApplicationK o, ActionGroupK a) => o -> a -> m ()-setApplicationActionGroup obj val = liftIO $ setObjectPropertyObject obj "action-group" val--constructApplicationActionGroup :: (ActionGroupK a) => a -> IO ([Char], GValue)-constructApplicationActionGroup val = constructObjectPropertyObject "action-group" val--data ApplicationActionGroupPropertyInfo-instance AttrInfo ApplicationActionGroupPropertyInfo where-    type AttrAllowedOps ApplicationActionGroupPropertyInfo = '[ 'AttrSet, 'AttrConstruct]-    type AttrSetTypeConstraint ApplicationActionGroupPropertyInfo = ActionGroupK-    type AttrBaseTypeConstraint ApplicationActionGroupPropertyInfo = ApplicationK-    type AttrGetType ApplicationActionGroupPropertyInfo = ()-    type AttrLabel ApplicationActionGroupPropertyInfo = "Application::action-group"-    attrGet _ = undefined-    attrSet _ = setApplicationActionGroup-    attrConstruct _ = constructApplicationActionGroup---- VVV Prop "application-id"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]--getApplicationApplicationId :: (MonadIO m, ApplicationK o) => o -> m T.Text-getApplicationApplicationId obj = liftIO $ getObjectPropertyString obj "application-id"--setApplicationApplicationId :: (MonadIO m, ApplicationK o) => o -> T.Text -> m ()-setApplicationApplicationId obj val = liftIO $ setObjectPropertyString obj "application-id" val--constructApplicationApplicationId :: T.Text -> IO ([Char], GValue)-constructApplicationApplicationId val = constructObjectPropertyString "application-id" val--data ApplicationApplicationIdPropertyInfo-instance AttrInfo ApplicationApplicationIdPropertyInfo where-    type AttrAllowedOps ApplicationApplicationIdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint ApplicationApplicationIdPropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint ApplicationApplicationIdPropertyInfo = ApplicationK-    type AttrGetType ApplicationApplicationIdPropertyInfo = T.Text-    type AttrLabel ApplicationApplicationIdPropertyInfo = "Application::application-id"-    attrGet _ = getApplicationApplicationId-    attrSet _ = setApplicationApplicationId-    attrConstruct _ = constructApplicationApplicationId---- VVV Prop "flags"-   -- Type: TInterface "Gio" "ApplicationFlags"-   -- Flags: [PropertyReadable,PropertyWritable]--getApplicationFlags :: (MonadIO m, ApplicationK o) => o -> m [ApplicationFlags]-getApplicationFlags obj = liftIO $ getObjectPropertyFlags obj "flags"--setApplicationFlags :: (MonadIO m, ApplicationK o) => o -> [ApplicationFlags] -> m ()-setApplicationFlags obj val = liftIO $ setObjectPropertyFlags obj "flags" val--constructApplicationFlags :: [ApplicationFlags] -> IO ([Char], GValue)-constructApplicationFlags val = constructObjectPropertyFlags "flags" val--data ApplicationFlagsPropertyInfo-instance AttrInfo ApplicationFlagsPropertyInfo where-    type AttrAllowedOps ApplicationFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint ApplicationFlagsPropertyInfo = (~) [ApplicationFlags]-    type AttrBaseTypeConstraint ApplicationFlagsPropertyInfo = ApplicationK-    type AttrGetType ApplicationFlagsPropertyInfo = [ApplicationFlags]-    type AttrLabel ApplicationFlagsPropertyInfo = "Application::flags"-    attrGet _ = getApplicationFlags-    attrSet _ = setApplicationFlags-    attrConstruct _ = constructApplicationFlags---- VVV Prop "inactivity-timeout"-   -- Type: TBasicType TUInt32-   -- Flags: [PropertyReadable,PropertyWritable]--getApplicationInactivityTimeout :: (MonadIO m, ApplicationK o) => o -> m Word32-getApplicationInactivityTimeout obj = liftIO $ getObjectPropertyCUInt obj "inactivity-timeout"--setApplicationInactivityTimeout :: (MonadIO m, ApplicationK o) => o -> Word32 -> m ()-setApplicationInactivityTimeout obj val = liftIO $ setObjectPropertyCUInt obj "inactivity-timeout" val--constructApplicationInactivityTimeout :: Word32 -> IO ([Char], GValue)-constructApplicationInactivityTimeout val = constructObjectPropertyCUInt "inactivity-timeout" val--data ApplicationInactivityTimeoutPropertyInfo-instance AttrInfo ApplicationInactivityTimeoutPropertyInfo where-    type AttrAllowedOps ApplicationInactivityTimeoutPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint ApplicationInactivityTimeoutPropertyInfo = (~) Word32-    type AttrBaseTypeConstraint ApplicationInactivityTimeoutPropertyInfo = ApplicationK-    type AttrGetType ApplicationInactivityTimeoutPropertyInfo = Word32-    type AttrLabel ApplicationInactivityTimeoutPropertyInfo = "Application::inactivity-timeout"-    attrGet _ = getApplicationInactivityTimeout-    attrSet _ = setApplicationInactivityTimeout-    attrConstruct _ = constructApplicationInactivityTimeout---- VVV Prop "is-busy"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable]--getApplicationIsBusy :: (MonadIO m, ApplicationK o) => o -> m Bool-getApplicationIsBusy obj = liftIO $ getObjectPropertyBool obj "is-busy"--data ApplicationIsBusyPropertyInfo-instance AttrInfo ApplicationIsBusyPropertyInfo where-    type AttrAllowedOps ApplicationIsBusyPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint ApplicationIsBusyPropertyInfo = (~) ()-    type AttrBaseTypeConstraint ApplicationIsBusyPropertyInfo = ApplicationK-    type AttrGetType ApplicationIsBusyPropertyInfo = Bool-    type AttrLabel ApplicationIsBusyPropertyInfo = "Application::is-busy"-    attrGet _ = getApplicationIsBusy-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "is-registered"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable]--getApplicationIsRegistered :: (MonadIO m, ApplicationK o) => o -> m Bool-getApplicationIsRegistered obj = liftIO $ getObjectPropertyBool obj "is-registered"--data ApplicationIsRegisteredPropertyInfo-instance AttrInfo ApplicationIsRegisteredPropertyInfo where-    type AttrAllowedOps ApplicationIsRegisteredPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint ApplicationIsRegisteredPropertyInfo = (~) ()-    type AttrBaseTypeConstraint ApplicationIsRegisteredPropertyInfo = ApplicationK-    type AttrGetType ApplicationIsRegisteredPropertyInfo = Bool-    type AttrLabel ApplicationIsRegisteredPropertyInfo = "Application::is-registered"-    attrGet _ = getApplicationIsRegistered-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "is-remote"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable]--getApplicationIsRemote :: (MonadIO m, ApplicationK o) => o -> m Bool-getApplicationIsRemote obj = liftIO $ getObjectPropertyBool obj "is-remote"--data ApplicationIsRemotePropertyInfo-instance AttrInfo ApplicationIsRemotePropertyInfo where-    type AttrAllowedOps ApplicationIsRemotePropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint ApplicationIsRemotePropertyInfo = (~) ()-    type AttrBaseTypeConstraint ApplicationIsRemotePropertyInfo = ApplicationK-    type AttrGetType ApplicationIsRemotePropertyInfo = Bool-    type AttrLabel ApplicationIsRemotePropertyInfo = "Application::is-remote"-    attrGet _ = getApplicationIsRemote-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "resource-base-path"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable]--getApplicationResourceBasePath :: (MonadIO m, ApplicationK o) => o -> m T.Text-getApplicationResourceBasePath obj = liftIO $ getObjectPropertyString obj "resource-base-path"--setApplicationResourceBasePath :: (MonadIO m, ApplicationK o) => o -> T.Text -> m ()-setApplicationResourceBasePath obj val = liftIO $ setObjectPropertyString obj "resource-base-path" val--constructApplicationResourceBasePath :: T.Text -> IO ([Char], GValue)-constructApplicationResourceBasePath val = constructObjectPropertyString "resource-base-path" val--data ApplicationResourceBasePathPropertyInfo-instance AttrInfo ApplicationResourceBasePathPropertyInfo where-    type AttrAllowedOps ApplicationResourceBasePathPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint ApplicationResourceBasePathPropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint ApplicationResourceBasePathPropertyInfo = ApplicationK-    type AttrGetType ApplicationResourceBasePathPropertyInfo = T.Text-    type AttrLabel ApplicationResourceBasePathPropertyInfo = "Application::resource-base-path"-    attrGet _ = getApplicationResourceBasePath-    attrSet _ = setApplicationResourceBasePath-    attrConstruct _ = constructApplicationResourceBasePath--type instance AttributeList Application = '[ '("action-group", ApplicationActionGroupPropertyInfo), '("application-id", ApplicationApplicationIdPropertyInfo), '("flags", ApplicationFlagsPropertyInfo), '("inactivity-timeout", ApplicationInactivityTimeoutPropertyInfo), '("is-busy", ApplicationIsBusyPropertyInfo), '("is-registered", ApplicationIsRegisteredPropertyInfo), '("is-remote", ApplicationIsRemotePropertyInfo), '("resource-base-path", ApplicationResourceBasePathPropertyInfo)]---- VVV Prop "arguments"-   -- Type: TVariant-   -- Flags: [PropertyWritable,PropertyConstructOnly]--constructApplicationCommandLineArguments :: GVariant -> IO ([Char], GValue)-constructApplicationCommandLineArguments val = constructObjectPropertyVariant "arguments" val--data ApplicationCommandLineArgumentsPropertyInfo-instance AttrInfo ApplicationCommandLineArgumentsPropertyInfo where-    type AttrAllowedOps ApplicationCommandLineArgumentsPropertyInfo = '[ 'AttrConstruct]-    type AttrSetTypeConstraint ApplicationCommandLineArgumentsPropertyInfo = (~) GVariant-    type AttrBaseTypeConstraint ApplicationCommandLineArgumentsPropertyInfo = ApplicationCommandLineK-    type AttrGetType ApplicationCommandLineArgumentsPropertyInfo = ()-    type AttrLabel ApplicationCommandLineArgumentsPropertyInfo = "ApplicationCommandLine::arguments"-    attrGet _ = undefined-    attrSet _ = undefined-    attrConstruct _ = constructApplicationCommandLineArguments---- VVV Prop "is-remote"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable]--getApplicationCommandLineIsRemote :: (MonadIO m, ApplicationCommandLineK o) => o -> m Bool-getApplicationCommandLineIsRemote obj = liftIO $ getObjectPropertyBool obj "is-remote"--data ApplicationCommandLineIsRemotePropertyInfo-instance AttrInfo ApplicationCommandLineIsRemotePropertyInfo where-    type AttrAllowedOps ApplicationCommandLineIsRemotePropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint ApplicationCommandLineIsRemotePropertyInfo = (~) ()-    type AttrBaseTypeConstraint ApplicationCommandLineIsRemotePropertyInfo = ApplicationCommandLineK-    type AttrGetType ApplicationCommandLineIsRemotePropertyInfo = Bool-    type AttrLabel ApplicationCommandLineIsRemotePropertyInfo = "ApplicationCommandLine::is-remote"-    attrGet _ = getApplicationCommandLineIsRemote-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "options"-   -- Type: TVariant-   -- Flags: [PropertyWritable,PropertyConstructOnly]--constructApplicationCommandLineOptions :: GVariant -> IO ([Char], GValue)-constructApplicationCommandLineOptions val = constructObjectPropertyVariant "options" val--data ApplicationCommandLineOptionsPropertyInfo-instance AttrInfo ApplicationCommandLineOptionsPropertyInfo where-    type AttrAllowedOps ApplicationCommandLineOptionsPropertyInfo = '[ 'AttrConstruct]-    type AttrSetTypeConstraint ApplicationCommandLineOptionsPropertyInfo = (~) GVariant-    type AttrBaseTypeConstraint ApplicationCommandLineOptionsPropertyInfo = ApplicationCommandLineK-    type AttrGetType ApplicationCommandLineOptionsPropertyInfo = ()-    type AttrLabel ApplicationCommandLineOptionsPropertyInfo = "ApplicationCommandLine::options"-    attrGet _ = undefined-    attrSet _ = undefined-    attrConstruct _ = constructApplicationCommandLineOptions---- VVV Prop "platform-data"-   -- Type: TVariant-   -- Flags: [PropertyWritable,PropertyConstructOnly]--constructApplicationCommandLinePlatformData :: GVariant -> IO ([Char], GValue)-constructApplicationCommandLinePlatformData val = constructObjectPropertyVariant "platform-data" val--data ApplicationCommandLinePlatformDataPropertyInfo-instance AttrInfo ApplicationCommandLinePlatformDataPropertyInfo where-    type AttrAllowedOps ApplicationCommandLinePlatformDataPropertyInfo = '[ 'AttrConstruct]-    type AttrSetTypeConstraint ApplicationCommandLinePlatformDataPropertyInfo = (~) GVariant-    type AttrBaseTypeConstraint ApplicationCommandLinePlatformDataPropertyInfo = ApplicationCommandLineK-    type AttrGetType ApplicationCommandLinePlatformDataPropertyInfo = ()-    type AttrLabel ApplicationCommandLinePlatformDataPropertyInfo = "ApplicationCommandLine::platform-data"-    attrGet _ = undefined-    attrSet _ = undefined-    attrConstruct _ = constructApplicationCommandLinePlatformData--type instance AttributeList ApplicationCommandLine = '[ '("arguments", ApplicationCommandLineArgumentsPropertyInfo), '("is-remote", ApplicationCommandLineIsRemotePropertyInfo), '("options", ApplicationCommandLineOptionsPropertyInfo), '("platform-data", ApplicationCommandLinePlatformDataPropertyInfo)]--type instance AttributeList AsyncInitable = '[ ]--type instance AttributeList AsyncResult = '[ ]---- VVV Prop "buffer-size"-   -- Type: TBasicType TUInt32-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]--getBufferedInputStreamBufferSize :: (MonadIO m, BufferedInputStreamK o) => o -> m Word32-getBufferedInputStreamBufferSize obj = liftIO $ getObjectPropertyCUInt obj "buffer-size"--setBufferedInputStreamBufferSize :: (MonadIO m, BufferedInputStreamK o) => o -> Word32 -> m ()-setBufferedInputStreamBufferSize obj val = liftIO $ setObjectPropertyCUInt obj "buffer-size" val--constructBufferedInputStreamBufferSize :: Word32 -> IO ([Char], GValue)-constructBufferedInputStreamBufferSize val = constructObjectPropertyCUInt "buffer-size" val--data BufferedInputStreamBufferSizePropertyInfo-instance AttrInfo BufferedInputStreamBufferSizePropertyInfo where-    type AttrAllowedOps BufferedInputStreamBufferSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint BufferedInputStreamBufferSizePropertyInfo = (~) Word32-    type AttrBaseTypeConstraint BufferedInputStreamBufferSizePropertyInfo = BufferedInputStreamK-    type AttrGetType BufferedInputStreamBufferSizePropertyInfo = Word32-    type AttrLabel BufferedInputStreamBufferSizePropertyInfo = "BufferedInputStream::buffer-size"-    attrGet _ = getBufferedInputStreamBufferSize-    attrSet _ = setBufferedInputStreamBufferSize-    attrConstruct _ = constructBufferedInputStreamBufferSize--type instance AttributeList BufferedInputStream = '[ '("base-stream", FilterInputStreamBaseStreamPropertyInfo), '("buffer-size", BufferedInputStreamBufferSizePropertyInfo), '("close-base-stream", FilterInputStreamCloseBaseStreamPropertyInfo)]---- VVV Prop "auto-grow"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable,PropertyWritable]--getBufferedOutputStreamAutoGrow :: (MonadIO m, BufferedOutputStreamK o) => o -> m Bool-getBufferedOutputStreamAutoGrow obj = liftIO $ getObjectPropertyBool obj "auto-grow"--setBufferedOutputStreamAutoGrow :: (MonadIO m, BufferedOutputStreamK o) => o -> Bool -> m ()-setBufferedOutputStreamAutoGrow obj val = liftIO $ setObjectPropertyBool obj "auto-grow" val--constructBufferedOutputStreamAutoGrow :: Bool -> IO ([Char], GValue)-constructBufferedOutputStreamAutoGrow val = constructObjectPropertyBool "auto-grow" val--data BufferedOutputStreamAutoGrowPropertyInfo-instance AttrInfo BufferedOutputStreamAutoGrowPropertyInfo where-    type AttrAllowedOps BufferedOutputStreamAutoGrowPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint BufferedOutputStreamAutoGrowPropertyInfo = (~) Bool-    type AttrBaseTypeConstraint BufferedOutputStreamAutoGrowPropertyInfo = BufferedOutputStreamK-    type AttrGetType BufferedOutputStreamAutoGrowPropertyInfo = Bool-    type AttrLabel BufferedOutputStreamAutoGrowPropertyInfo = "BufferedOutputStream::auto-grow"-    attrGet _ = getBufferedOutputStreamAutoGrow-    attrSet _ = setBufferedOutputStreamAutoGrow-    attrConstruct _ = constructBufferedOutputStreamAutoGrow---- VVV Prop "buffer-size"-   -- Type: TBasicType TUInt32-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]--getBufferedOutputStreamBufferSize :: (MonadIO m, BufferedOutputStreamK o) => o -> m Word32-getBufferedOutputStreamBufferSize obj = liftIO $ getObjectPropertyCUInt obj "buffer-size"--setBufferedOutputStreamBufferSize :: (MonadIO m, BufferedOutputStreamK o) => o -> Word32 -> m ()-setBufferedOutputStreamBufferSize obj val = liftIO $ setObjectPropertyCUInt obj "buffer-size" val--constructBufferedOutputStreamBufferSize :: Word32 -> IO ([Char], GValue)-constructBufferedOutputStreamBufferSize val = constructObjectPropertyCUInt "buffer-size" val--data BufferedOutputStreamBufferSizePropertyInfo-instance AttrInfo BufferedOutputStreamBufferSizePropertyInfo where-    type AttrAllowedOps BufferedOutputStreamBufferSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint BufferedOutputStreamBufferSizePropertyInfo = (~) Word32-    type AttrBaseTypeConstraint BufferedOutputStreamBufferSizePropertyInfo = BufferedOutputStreamK-    type AttrGetType BufferedOutputStreamBufferSizePropertyInfo = Word32-    type AttrLabel BufferedOutputStreamBufferSizePropertyInfo = "BufferedOutputStream::buffer-size"-    attrGet _ = getBufferedOutputStreamBufferSize-    attrSet _ = setBufferedOutputStreamBufferSize-    attrConstruct _ = constructBufferedOutputStreamBufferSize--type instance AttributeList BufferedOutputStream = '[ '("auto-grow", BufferedOutputStreamAutoGrowPropertyInfo), '("base-stream", FilterOutputStreamBaseStreamPropertyInfo), '("buffer-size", BufferedOutputStreamBufferSizePropertyInfo), '("close-base-stream", FilterOutputStreamCloseBaseStreamPropertyInfo)]---- VVV Prop "bytes"-   -- Type: TInterface "GLib" "Bytes"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getBytesIconBytes :: (MonadIO m, BytesIconK o) => o -> m GLib.Bytes-getBytesIconBytes obj = liftIO $ getObjectPropertyBoxed obj "bytes" GLib.Bytes--constructBytesIconBytes :: GLib.Bytes -> IO ([Char], GValue)-constructBytesIconBytes val = constructObjectPropertyBoxed "bytes" val--data BytesIconBytesPropertyInfo-instance AttrInfo BytesIconBytesPropertyInfo where-    type AttrAllowedOps BytesIconBytesPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint BytesIconBytesPropertyInfo = (~) GLib.Bytes-    type AttrBaseTypeConstraint BytesIconBytesPropertyInfo = BytesIconK-    type AttrGetType BytesIconBytesPropertyInfo = GLib.Bytes-    type AttrLabel BytesIconBytesPropertyInfo = "BytesIcon::bytes"-    attrGet _ = getBytesIconBytes-    attrSet _ = undefined-    attrConstruct _ = constructBytesIconBytes--type instance AttributeList BytesIcon = '[ '("bytes", BytesIconBytesPropertyInfo)]--type instance AttributeList Cancellable = '[ ]---- VVV Prop "from-charset"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getCharsetConverterFromCharset :: (MonadIO m, CharsetConverterK o) => o -> m T.Text-getCharsetConverterFromCharset obj = liftIO $ getObjectPropertyString obj "from-charset"--constructCharsetConverterFromCharset :: T.Text -> IO ([Char], GValue)-constructCharsetConverterFromCharset val = constructObjectPropertyString "from-charset" val--data CharsetConverterFromCharsetPropertyInfo-instance AttrInfo CharsetConverterFromCharsetPropertyInfo where-    type AttrAllowedOps CharsetConverterFromCharsetPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint CharsetConverterFromCharsetPropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint CharsetConverterFromCharsetPropertyInfo = CharsetConverterK-    type AttrGetType CharsetConverterFromCharsetPropertyInfo = T.Text-    type AttrLabel CharsetConverterFromCharsetPropertyInfo = "CharsetConverter::from-charset"-    attrGet _ = getCharsetConverterFromCharset-    attrSet _ = undefined-    attrConstruct _ = constructCharsetConverterFromCharset---- VVV Prop "to-charset"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getCharsetConverterToCharset :: (MonadIO m, CharsetConverterK o) => o -> m T.Text-getCharsetConverterToCharset obj = liftIO $ getObjectPropertyString obj "to-charset"--constructCharsetConverterToCharset :: T.Text -> IO ([Char], GValue)-constructCharsetConverterToCharset val = constructObjectPropertyString "to-charset" val--data CharsetConverterToCharsetPropertyInfo-instance AttrInfo CharsetConverterToCharsetPropertyInfo where-    type AttrAllowedOps CharsetConverterToCharsetPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint CharsetConverterToCharsetPropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint CharsetConverterToCharsetPropertyInfo = CharsetConverterK-    type AttrGetType CharsetConverterToCharsetPropertyInfo = T.Text-    type AttrLabel CharsetConverterToCharsetPropertyInfo = "CharsetConverter::to-charset"-    attrGet _ = getCharsetConverterToCharset-    attrSet _ = undefined-    attrConstruct _ = constructCharsetConverterToCharset---- VVV Prop "use-fallback"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]--getCharsetConverterUseFallback :: (MonadIO m, CharsetConverterK o) => o -> m Bool-getCharsetConverterUseFallback obj = liftIO $ getObjectPropertyBool obj "use-fallback"--setCharsetConverterUseFallback :: (MonadIO m, CharsetConverterK o) => o -> Bool -> m ()-setCharsetConverterUseFallback obj val = liftIO $ setObjectPropertyBool obj "use-fallback" val--constructCharsetConverterUseFallback :: Bool -> IO ([Char], GValue)-constructCharsetConverterUseFallback val = constructObjectPropertyBool "use-fallback" val--data CharsetConverterUseFallbackPropertyInfo-instance AttrInfo CharsetConverterUseFallbackPropertyInfo where-    type AttrAllowedOps CharsetConverterUseFallbackPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint CharsetConverterUseFallbackPropertyInfo = (~) Bool-    type AttrBaseTypeConstraint CharsetConverterUseFallbackPropertyInfo = CharsetConverterK-    type AttrGetType CharsetConverterUseFallbackPropertyInfo = Bool-    type AttrLabel CharsetConverterUseFallbackPropertyInfo = "CharsetConverter::use-fallback"-    attrGet _ = getCharsetConverterUseFallback-    attrSet _ = setCharsetConverterUseFallback-    attrConstruct _ = constructCharsetConverterUseFallback--type instance AttributeList CharsetConverter = '[ '("from-charset", CharsetConverterFromCharsetPropertyInfo), '("to-charset", CharsetConverterToCharsetPropertyInfo), '("use-fallback", CharsetConverterUseFallbackPropertyInfo)]--type instance AttributeList Converter = '[ ]---- VVV Prop "converter"-   -- Type: TInterface "Gio" "Converter"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getConverterInputStreamConverter :: (MonadIO m, ConverterInputStreamK o) => o -> m Converter-getConverterInputStreamConverter obj = liftIO $ getObjectPropertyObject obj "converter" Converter--constructConverterInputStreamConverter :: (ConverterK a) => a -> IO ([Char], GValue)-constructConverterInputStreamConverter val = constructObjectPropertyObject "converter" val--data ConverterInputStreamConverterPropertyInfo-instance AttrInfo ConverterInputStreamConverterPropertyInfo where-    type AttrAllowedOps ConverterInputStreamConverterPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint ConverterInputStreamConverterPropertyInfo = ConverterK-    type AttrBaseTypeConstraint ConverterInputStreamConverterPropertyInfo = ConverterInputStreamK-    type AttrGetType ConverterInputStreamConverterPropertyInfo = Converter-    type AttrLabel ConverterInputStreamConverterPropertyInfo = "ConverterInputStream::converter"-    attrGet _ = getConverterInputStreamConverter-    attrSet _ = undefined-    attrConstruct _ = constructConverterInputStreamConverter--type instance AttributeList ConverterInputStream = '[ '("base-stream", FilterInputStreamBaseStreamPropertyInfo), '("close-base-stream", FilterInputStreamCloseBaseStreamPropertyInfo), '("converter", ConverterInputStreamConverterPropertyInfo)]---- VVV Prop "converter"-   -- Type: TInterface "Gio" "Converter"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getConverterOutputStreamConverter :: (MonadIO m, ConverterOutputStreamK o) => o -> m Converter-getConverterOutputStreamConverter obj = liftIO $ getObjectPropertyObject obj "converter" Converter--constructConverterOutputStreamConverter :: (ConverterK a) => a -> IO ([Char], GValue)-constructConverterOutputStreamConverter val = constructObjectPropertyObject "converter" val--data ConverterOutputStreamConverterPropertyInfo-instance AttrInfo ConverterOutputStreamConverterPropertyInfo where-    type AttrAllowedOps ConverterOutputStreamConverterPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint ConverterOutputStreamConverterPropertyInfo = ConverterK-    type AttrBaseTypeConstraint ConverterOutputStreamConverterPropertyInfo = ConverterOutputStreamK-    type AttrGetType ConverterOutputStreamConverterPropertyInfo = Converter-    type AttrLabel ConverterOutputStreamConverterPropertyInfo = "ConverterOutputStream::converter"-    attrGet _ = getConverterOutputStreamConverter-    attrSet _ = undefined-    attrConstruct _ = constructConverterOutputStreamConverter--type instance AttributeList ConverterOutputStream = '[ '("base-stream", FilterOutputStreamBaseStreamPropertyInfo), '("close-base-stream", FilterOutputStreamCloseBaseStreamPropertyInfo), '("converter", ConverterOutputStreamConverterPropertyInfo)]--type instance AttributeList Credentials = '[ ]--type instance AttributeList DBusActionGroup = '[ ]--type instance AttributeList DBusAuthObserver = '[ ]---- VVV Prop "address"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyWritable,PropertyConstructOnly]--constructDBusConnectionAddress :: T.Text -> IO ([Char], GValue)-constructDBusConnectionAddress val = constructObjectPropertyString "address" val--data DBusConnectionAddressPropertyInfo-instance AttrInfo DBusConnectionAddressPropertyInfo where-    type AttrAllowedOps DBusConnectionAddressPropertyInfo = '[ 'AttrConstruct]-    type AttrSetTypeConstraint DBusConnectionAddressPropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint DBusConnectionAddressPropertyInfo = DBusConnectionK-    type AttrGetType DBusConnectionAddressPropertyInfo = ()-    type AttrLabel DBusConnectionAddressPropertyInfo = "DBusConnection::address"-    attrGet _ = undefined-    attrSet _ = undefined-    attrConstruct _ = constructDBusConnectionAddress---- VVV Prop "authentication-observer"-   -- Type: TInterface "Gio" "DBusAuthObserver"-   -- Flags: [PropertyWritable,PropertyConstructOnly]--constructDBusConnectionAuthenticationObserver :: (DBusAuthObserverK a) => a -> IO ([Char], GValue)-constructDBusConnectionAuthenticationObserver val = constructObjectPropertyObject "authentication-observer" val--data DBusConnectionAuthenticationObserverPropertyInfo-instance AttrInfo DBusConnectionAuthenticationObserverPropertyInfo where-    type AttrAllowedOps DBusConnectionAuthenticationObserverPropertyInfo = '[ 'AttrConstruct]-    type AttrSetTypeConstraint DBusConnectionAuthenticationObserverPropertyInfo = DBusAuthObserverK-    type AttrBaseTypeConstraint DBusConnectionAuthenticationObserverPropertyInfo = DBusConnectionK-    type AttrGetType DBusConnectionAuthenticationObserverPropertyInfo = ()-    type AttrLabel DBusConnectionAuthenticationObserverPropertyInfo = "DBusConnection::authentication-observer"-    attrGet _ = undefined-    attrSet _ = undefined-    attrConstruct _ = constructDBusConnectionAuthenticationObserver---- VVV Prop "capabilities"-   -- Type: TInterface "Gio" "DBusCapabilityFlags"-   -- Flags: [PropertyReadable]--getDBusConnectionCapabilities :: (MonadIO m, DBusConnectionK o) => o -> m [DBusCapabilityFlags]-getDBusConnectionCapabilities obj = liftIO $ getObjectPropertyFlags obj "capabilities"--data DBusConnectionCapabilitiesPropertyInfo-instance AttrInfo DBusConnectionCapabilitiesPropertyInfo where-    type AttrAllowedOps DBusConnectionCapabilitiesPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint DBusConnectionCapabilitiesPropertyInfo = (~) ()-    type AttrBaseTypeConstraint DBusConnectionCapabilitiesPropertyInfo = DBusConnectionK-    type AttrGetType DBusConnectionCapabilitiesPropertyInfo = [DBusCapabilityFlags]-    type AttrLabel DBusConnectionCapabilitiesPropertyInfo = "DBusConnection::capabilities"-    attrGet _ = getDBusConnectionCapabilities-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "closed"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable]--getDBusConnectionClosed :: (MonadIO m, DBusConnectionK o) => o -> m Bool-getDBusConnectionClosed obj = liftIO $ getObjectPropertyBool obj "closed"--data DBusConnectionClosedPropertyInfo-instance AttrInfo DBusConnectionClosedPropertyInfo where-    type AttrAllowedOps DBusConnectionClosedPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint DBusConnectionClosedPropertyInfo = (~) ()-    type AttrBaseTypeConstraint DBusConnectionClosedPropertyInfo = DBusConnectionK-    type AttrGetType DBusConnectionClosedPropertyInfo = Bool-    type AttrLabel DBusConnectionClosedPropertyInfo = "DBusConnection::closed"-    attrGet _ = getDBusConnectionClosed-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "exit-on-close"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable,PropertyWritable]--getDBusConnectionExitOnClose :: (MonadIO m, DBusConnectionK o) => o -> m Bool-getDBusConnectionExitOnClose obj = liftIO $ getObjectPropertyBool obj "exit-on-close"--setDBusConnectionExitOnClose :: (MonadIO m, DBusConnectionK o) => o -> Bool -> m ()-setDBusConnectionExitOnClose obj val = liftIO $ setObjectPropertyBool obj "exit-on-close" val--constructDBusConnectionExitOnClose :: Bool -> IO ([Char], GValue)-constructDBusConnectionExitOnClose val = constructObjectPropertyBool "exit-on-close" val--data DBusConnectionExitOnClosePropertyInfo-instance AttrInfo DBusConnectionExitOnClosePropertyInfo where-    type AttrAllowedOps DBusConnectionExitOnClosePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint DBusConnectionExitOnClosePropertyInfo = (~) Bool-    type AttrBaseTypeConstraint DBusConnectionExitOnClosePropertyInfo = DBusConnectionK-    type AttrGetType DBusConnectionExitOnClosePropertyInfo = Bool-    type AttrLabel DBusConnectionExitOnClosePropertyInfo = "DBusConnection::exit-on-close"-    attrGet _ = getDBusConnectionExitOnClose-    attrSet _ = setDBusConnectionExitOnClose-    attrConstruct _ = constructDBusConnectionExitOnClose---- VVV Prop "flags"-   -- Type: TInterface "Gio" "DBusConnectionFlags"-   -- Flags: [PropertyWritable,PropertyConstructOnly]--constructDBusConnectionFlags :: [DBusConnectionFlags] -> IO ([Char], GValue)-constructDBusConnectionFlags val = constructObjectPropertyFlags "flags" val--data DBusConnectionFlagsPropertyInfo-instance AttrInfo DBusConnectionFlagsPropertyInfo where-    type AttrAllowedOps DBusConnectionFlagsPropertyInfo = '[ 'AttrConstruct]-    type AttrSetTypeConstraint DBusConnectionFlagsPropertyInfo = (~) [DBusConnectionFlags]-    type AttrBaseTypeConstraint DBusConnectionFlagsPropertyInfo = DBusConnectionK-    type AttrGetType DBusConnectionFlagsPropertyInfo = ()-    type AttrLabel DBusConnectionFlagsPropertyInfo = "DBusConnection::flags"-    attrGet _ = undefined-    attrSet _ = undefined-    attrConstruct _ = constructDBusConnectionFlags---- VVV Prop "guid"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getDBusConnectionGuid :: (MonadIO m, DBusConnectionK o) => o -> m T.Text-getDBusConnectionGuid obj = liftIO $ getObjectPropertyString obj "guid"--constructDBusConnectionGuid :: T.Text -> IO ([Char], GValue)-constructDBusConnectionGuid val = constructObjectPropertyString "guid" val--data DBusConnectionGuidPropertyInfo-instance AttrInfo DBusConnectionGuidPropertyInfo where-    type AttrAllowedOps DBusConnectionGuidPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint DBusConnectionGuidPropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint DBusConnectionGuidPropertyInfo = DBusConnectionK-    type AttrGetType DBusConnectionGuidPropertyInfo = T.Text-    type AttrLabel DBusConnectionGuidPropertyInfo = "DBusConnection::guid"-    attrGet _ = getDBusConnectionGuid-    attrSet _ = undefined-    attrConstruct _ = constructDBusConnectionGuid---- VVV Prop "stream"-   -- Type: TInterface "Gio" "IOStream"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getDBusConnectionStream :: (MonadIO m, DBusConnectionK o) => o -> m IOStream-getDBusConnectionStream obj = liftIO $ getObjectPropertyObject obj "stream" IOStream--constructDBusConnectionStream :: (IOStreamK a) => a -> IO ([Char], GValue)-constructDBusConnectionStream val = constructObjectPropertyObject "stream" val--data DBusConnectionStreamPropertyInfo-instance AttrInfo DBusConnectionStreamPropertyInfo where-    type AttrAllowedOps DBusConnectionStreamPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint DBusConnectionStreamPropertyInfo = IOStreamK-    type AttrBaseTypeConstraint DBusConnectionStreamPropertyInfo = DBusConnectionK-    type AttrGetType DBusConnectionStreamPropertyInfo = IOStream-    type AttrLabel DBusConnectionStreamPropertyInfo = "DBusConnection::stream"-    attrGet _ = getDBusConnectionStream-    attrSet _ = undefined-    attrConstruct _ = constructDBusConnectionStream---- VVV Prop "unique-name"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable]--getDBusConnectionUniqueName :: (MonadIO m, DBusConnectionK o) => o -> m T.Text-getDBusConnectionUniqueName obj = liftIO $ getObjectPropertyString obj "unique-name"--data DBusConnectionUniqueNamePropertyInfo-instance AttrInfo DBusConnectionUniqueNamePropertyInfo where-    type AttrAllowedOps DBusConnectionUniqueNamePropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint DBusConnectionUniqueNamePropertyInfo = (~) ()-    type AttrBaseTypeConstraint DBusConnectionUniqueNamePropertyInfo = DBusConnectionK-    type AttrGetType DBusConnectionUniqueNamePropertyInfo = T.Text-    type AttrLabel DBusConnectionUniqueNamePropertyInfo = "DBusConnection::unique-name"-    attrGet _ = getDBusConnectionUniqueName-    attrSet _ = undefined-    attrConstruct _ = undefined--type instance AttributeList DBusConnection = '[ '("address", DBusConnectionAddressPropertyInfo), '("authentication-observer", DBusConnectionAuthenticationObserverPropertyInfo), '("capabilities", DBusConnectionCapabilitiesPropertyInfo), '("closed", DBusConnectionClosedPropertyInfo), '("exit-on-close", DBusConnectionExitOnClosePropertyInfo), '("flags", DBusConnectionFlagsPropertyInfo), '("guid", DBusConnectionGuidPropertyInfo), '("stream", DBusConnectionStreamPropertyInfo), '("unique-name", DBusConnectionUniqueNamePropertyInfo)]--type instance AttributeList DBusInterface = '[ ]---- VVV Prop "g-flags"-   -- Type: TInterface "Gio" "DBusInterfaceSkeletonFlags"-   -- Flags: [PropertyReadable,PropertyWritable]--getDBusInterfaceSkeletonGFlags :: (MonadIO m, DBusInterfaceSkeletonK o) => o -> m [DBusInterfaceSkeletonFlags]-getDBusInterfaceSkeletonGFlags obj = liftIO $ getObjectPropertyFlags obj "g-flags"--setDBusInterfaceSkeletonGFlags :: (MonadIO m, DBusInterfaceSkeletonK o) => o -> [DBusInterfaceSkeletonFlags] -> m ()-setDBusInterfaceSkeletonGFlags obj val = liftIO $ setObjectPropertyFlags obj "g-flags" val--constructDBusInterfaceSkeletonGFlags :: [DBusInterfaceSkeletonFlags] -> IO ([Char], GValue)-constructDBusInterfaceSkeletonGFlags val = constructObjectPropertyFlags "g-flags" val--data DBusInterfaceSkeletonGFlagsPropertyInfo-instance AttrInfo DBusInterfaceSkeletonGFlagsPropertyInfo where-    type AttrAllowedOps DBusInterfaceSkeletonGFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint DBusInterfaceSkeletonGFlagsPropertyInfo = (~) [DBusInterfaceSkeletonFlags]-    type AttrBaseTypeConstraint DBusInterfaceSkeletonGFlagsPropertyInfo = DBusInterfaceSkeletonK-    type AttrGetType DBusInterfaceSkeletonGFlagsPropertyInfo = [DBusInterfaceSkeletonFlags]-    type AttrLabel DBusInterfaceSkeletonGFlagsPropertyInfo = "DBusInterfaceSkeleton::g-flags"-    attrGet _ = getDBusInterfaceSkeletonGFlags-    attrSet _ = setDBusInterfaceSkeletonGFlags-    attrConstruct _ = constructDBusInterfaceSkeletonGFlags--type instance AttributeList DBusInterfaceSkeleton = '[ '("g-flags", DBusInterfaceSkeletonGFlagsPropertyInfo)]--type instance AttributeList DBusMenuModel = '[ ]---- VVV Prop "locked"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable]--getDBusMessageLocked :: (MonadIO m, DBusMessageK o) => o -> m Bool-getDBusMessageLocked obj = liftIO $ getObjectPropertyBool obj "locked"--data DBusMessageLockedPropertyInfo-instance AttrInfo DBusMessageLockedPropertyInfo where-    type AttrAllowedOps DBusMessageLockedPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint DBusMessageLockedPropertyInfo = (~) ()-    type AttrBaseTypeConstraint DBusMessageLockedPropertyInfo = DBusMessageK-    type AttrGetType DBusMessageLockedPropertyInfo = Bool-    type AttrLabel DBusMessageLockedPropertyInfo = "DBusMessage::locked"-    attrGet _ = getDBusMessageLocked-    attrSet _ = undefined-    attrConstruct _ = undefined--type instance AttributeList DBusMessage = '[ '("locked", DBusMessageLockedPropertyInfo)]--type instance AttributeList DBusMethodInvocation = '[ ]--type instance AttributeList DBusObject = '[ ]--type instance AttributeList DBusObjectManager = '[ ]---- VVV Prop "bus-type"-   -- Type: TInterface "Gio" "BusType"-   -- Flags: [PropertyWritable,PropertyConstructOnly]--constructDBusObjectManagerClientBusType :: BusType -> IO ([Char], GValue)-constructDBusObjectManagerClientBusType val = constructObjectPropertyEnum "bus-type" val--data DBusObjectManagerClientBusTypePropertyInfo-instance AttrInfo DBusObjectManagerClientBusTypePropertyInfo where-    type AttrAllowedOps DBusObjectManagerClientBusTypePropertyInfo = '[ 'AttrConstruct]-    type AttrSetTypeConstraint DBusObjectManagerClientBusTypePropertyInfo = (~) BusType-    type AttrBaseTypeConstraint DBusObjectManagerClientBusTypePropertyInfo = DBusObjectManagerClientK-    type AttrGetType DBusObjectManagerClientBusTypePropertyInfo = ()-    type AttrLabel DBusObjectManagerClientBusTypePropertyInfo = "DBusObjectManagerClient::bus-type"-    attrGet _ = undefined-    attrSet _ = undefined-    attrConstruct _ = constructDBusObjectManagerClientBusType---- VVV Prop "connection"-   -- Type: TInterface "Gio" "DBusConnection"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getDBusObjectManagerClientConnection :: (MonadIO m, DBusObjectManagerClientK o) => o -> m DBusConnection-getDBusObjectManagerClientConnection obj = liftIO $ getObjectPropertyObject obj "connection" DBusConnection--constructDBusObjectManagerClientConnection :: (DBusConnectionK a) => a -> IO ([Char], GValue)-constructDBusObjectManagerClientConnection val = constructObjectPropertyObject "connection" val--data DBusObjectManagerClientConnectionPropertyInfo-instance AttrInfo DBusObjectManagerClientConnectionPropertyInfo where-    type AttrAllowedOps DBusObjectManagerClientConnectionPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint DBusObjectManagerClientConnectionPropertyInfo = DBusConnectionK-    type AttrBaseTypeConstraint DBusObjectManagerClientConnectionPropertyInfo = DBusObjectManagerClientK-    type AttrGetType DBusObjectManagerClientConnectionPropertyInfo = DBusConnection-    type AttrLabel DBusObjectManagerClientConnectionPropertyInfo = "DBusObjectManagerClient::connection"-    attrGet _ = getDBusObjectManagerClientConnection-    attrSet _ = undefined-    attrConstruct _ = constructDBusObjectManagerClientConnection---- VVV Prop "flags"-   -- Type: TInterface "Gio" "DBusObjectManagerClientFlags"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getDBusObjectManagerClientFlags :: (MonadIO m, DBusObjectManagerClientK o) => o -> m [DBusObjectManagerClientFlags]-getDBusObjectManagerClientFlags obj = liftIO $ getObjectPropertyFlags obj "flags"--constructDBusObjectManagerClientFlags :: [DBusObjectManagerClientFlags] -> IO ([Char], GValue)-constructDBusObjectManagerClientFlags val = constructObjectPropertyFlags "flags" val--data DBusObjectManagerClientFlagsPropertyInfo-instance AttrInfo DBusObjectManagerClientFlagsPropertyInfo where-    type AttrAllowedOps DBusObjectManagerClientFlagsPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint DBusObjectManagerClientFlagsPropertyInfo = (~) [DBusObjectManagerClientFlags]-    type AttrBaseTypeConstraint DBusObjectManagerClientFlagsPropertyInfo = DBusObjectManagerClientK-    type AttrGetType DBusObjectManagerClientFlagsPropertyInfo = [DBusObjectManagerClientFlags]-    type AttrLabel DBusObjectManagerClientFlagsPropertyInfo = "DBusObjectManagerClient::flags"-    attrGet _ = getDBusObjectManagerClientFlags-    attrSet _ = undefined-    attrConstruct _ = constructDBusObjectManagerClientFlags---- VVV Prop "get-proxy-type-destroy-notify"-   -- Type: TBasicType TVoid-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getDBusObjectManagerClientGetProxyTypeDestroyNotify :: (MonadIO m, DBusObjectManagerClientK o) => o -> m (Ptr ())-getDBusObjectManagerClientGetProxyTypeDestroyNotify obj = liftIO $ getObjectPropertyPtr obj "get-proxy-type-destroy-notify"--constructDBusObjectManagerClientGetProxyTypeDestroyNotify :: (Ptr ()) -> IO ([Char], GValue)-constructDBusObjectManagerClientGetProxyTypeDestroyNotify val = constructObjectPropertyPtr "get-proxy-type-destroy-notify" val--data DBusObjectManagerClientGetProxyTypeDestroyNotifyPropertyInfo-instance AttrInfo DBusObjectManagerClientGetProxyTypeDestroyNotifyPropertyInfo where-    type AttrAllowedOps DBusObjectManagerClientGetProxyTypeDestroyNotifyPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint DBusObjectManagerClientGetProxyTypeDestroyNotifyPropertyInfo = (~) (Ptr ())-    type AttrBaseTypeConstraint DBusObjectManagerClientGetProxyTypeDestroyNotifyPropertyInfo = DBusObjectManagerClientK-    type AttrGetType DBusObjectManagerClientGetProxyTypeDestroyNotifyPropertyInfo = (Ptr ())-    type AttrLabel DBusObjectManagerClientGetProxyTypeDestroyNotifyPropertyInfo = "DBusObjectManagerClient::get-proxy-type-destroy-notify"-    attrGet _ = getDBusObjectManagerClientGetProxyTypeDestroyNotify-    attrSet _ = undefined-    attrConstruct _ = constructDBusObjectManagerClientGetProxyTypeDestroyNotify---- VVV Prop "get-proxy-type-func"-   -- Type: TBasicType TVoid-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getDBusObjectManagerClientGetProxyTypeFunc :: (MonadIO m, DBusObjectManagerClientK o) => o -> m (Ptr ())-getDBusObjectManagerClientGetProxyTypeFunc obj = liftIO $ getObjectPropertyPtr obj "get-proxy-type-func"--constructDBusObjectManagerClientGetProxyTypeFunc :: (Ptr ()) -> IO ([Char], GValue)-constructDBusObjectManagerClientGetProxyTypeFunc val = constructObjectPropertyPtr "get-proxy-type-func" val--data DBusObjectManagerClientGetProxyTypeFuncPropertyInfo-instance AttrInfo DBusObjectManagerClientGetProxyTypeFuncPropertyInfo where-    type AttrAllowedOps DBusObjectManagerClientGetProxyTypeFuncPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint DBusObjectManagerClientGetProxyTypeFuncPropertyInfo = (~) (Ptr ())-    type AttrBaseTypeConstraint DBusObjectManagerClientGetProxyTypeFuncPropertyInfo = DBusObjectManagerClientK-    type AttrGetType DBusObjectManagerClientGetProxyTypeFuncPropertyInfo = (Ptr ())-    type AttrLabel DBusObjectManagerClientGetProxyTypeFuncPropertyInfo = "DBusObjectManagerClient::get-proxy-type-func"-    attrGet _ = getDBusObjectManagerClientGetProxyTypeFunc-    attrSet _ = undefined-    attrConstruct _ = constructDBusObjectManagerClientGetProxyTypeFunc---- VVV Prop "get-proxy-type-user-data"-   -- Type: TBasicType TVoid-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getDBusObjectManagerClientGetProxyTypeUserData :: (MonadIO m, DBusObjectManagerClientK o) => o -> m (Ptr ())-getDBusObjectManagerClientGetProxyTypeUserData obj = liftIO $ getObjectPropertyPtr obj "get-proxy-type-user-data"--constructDBusObjectManagerClientGetProxyTypeUserData :: (Ptr ()) -> IO ([Char], GValue)-constructDBusObjectManagerClientGetProxyTypeUserData val = constructObjectPropertyPtr "get-proxy-type-user-data" val--data DBusObjectManagerClientGetProxyTypeUserDataPropertyInfo-instance AttrInfo DBusObjectManagerClientGetProxyTypeUserDataPropertyInfo where-    type AttrAllowedOps DBusObjectManagerClientGetProxyTypeUserDataPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint DBusObjectManagerClientGetProxyTypeUserDataPropertyInfo = (~) (Ptr ())-    type AttrBaseTypeConstraint DBusObjectManagerClientGetProxyTypeUserDataPropertyInfo = DBusObjectManagerClientK-    type AttrGetType DBusObjectManagerClientGetProxyTypeUserDataPropertyInfo = (Ptr ())-    type AttrLabel DBusObjectManagerClientGetProxyTypeUserDataPropertyInfo = "DBusObjectManagerClient::get-proxy-type-user-data"-    attrGet _ = getDBusObjectManagerClientGetProxyTypeUserData-    attrSet _ = undefined-    attrConstruct _ = constructDBusObjectManagerClientGetProxyTypeUserData---- VVV Prop "name"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getDBusObjectManagerClientName :: (MonadIO m, DBusObjectManagerClientK o) => o -> m T.Text-getDBusObjectManagerClientName obj = liftIO $ getObjectPropertyString obj "name"--constructDBusObjectManagerClientName :: T.Text -> IO ([Char], GValue)-constructDBusObjectManagerClientName val = constructObjectPropertyString "name" val--data DBusObjectManagerClientNamePropertyInfo-instance AttrInfo DBusObjectManagerClientNamePropertyInfo where-    type AttrAllowedOps DBusObjectManagerClientNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint DBusObjectManagerClientNamePropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint DBusObjectManagerClientNamePropertyInfo = DBusObjectManagerClientK-    type AttrGetType DBusObjectManagerClientNamePropertyInfo = T.Text-    type AttrLabel DBusObjectManagerClientNamePropertyInfo = "DBusObjectManagerClient::name"-    attrGet _ = getDBusObjectManagerClientName-    attrSet _ = undefined-    attrConstruct _ = constructDBusObjectManagerClientName---- VVV Prop "name-owner"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable]--getDBusObjectManagerClientNameOwner :: (MonadIO m, DBusObjectManagerClientK o) => o -> m T.Text-getDBusObjectManagerClientNameOwner obj = liftIO $ getObjectPropertyString obj "name-owner"--data DBusObjectManagerClientNameOwnerPropertyInfo-instance AttrInfo DBusObjectManagerClientNameOwnerPropertyInfo where-    type AttrAllowedOps DBusObjectManagerClientNameOwnerPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint DBusObjectManagerClientNameOwnerPropertyInfo = (~) ()-    type AttrBaseTypeConstraint DBusObjectManagerClientNameOwnerPropertyInfo = DBusObjectManagerClientK-    type AttrGetType DBusObjectManagerClientNameOwnerPropertyInfo = T.Text-    type AttrLabel DBusObjectManagerClientNameOwnerPropertyInfo = "DBusObjectManagerClient::name-owner"-    attrGet _ = getDBusObjectManagerClientNameOwner-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "object-path"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getDBusObjectManagerClientObjectPath :: (MonadIO m, DBusObjectManagerClientK o) => o -> m T.Text-getDBusObjectManagerClientObjectPath obj = liftIO $ getObjectPropertyString obj "object-path"--constructDBusObjectManagerClientObjectPath :: T.Text -> IO ([Char], GValue)-constructDBusObjectManagerClientObjectPath val = constructObjectPropertyString "object-path" val--data DBusObjectManagerClientObjectPathPropertyInfo-instance AttrInfo DBusObjectManagerClientObjectPathPropertyInfo where-    type AttrAllowedOps DBusObjectManagerClientObjectPathPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint DBusObjectManagerClientObjectPathPropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint DBusObjectManagerClientObjectPathPropertyInfo = DBusObjectManagerClientK-    type AttrGetType DBusObjectManagerClientObjectPathPropertyInfo = T.Text-    type AttrLabel DBusObjectManagerClientObjectPathPropertyInfo = "DBusObjectManagerClient::object-path"-    attrGet _ = getDBusObjectManagerClientObjectPath-    attrSet _ = undefined-    attrConstruct _ = constructDBusObjectManagerClientObjectPath--type instance AttributeList DBusObjectManagerClient = '[ '("bus-type", DBusObjectManagerClientBusTypePropertyInfo), '("connection", DBusObjectManagerClientConnectionPropertyInfo), '("flags", DBusObjectManagerClientFlagsPropertyInfo), '("get-proxy-type-destroy-notify", DBusObjectManagerClientGetProxyTypeDestroyNotifyPropertyInfo), '("get-proxy-type-func", DBusObjectManagerClientGetProxyTypeFuncPropertyInfo), '("get-proxy-type-user-data", DBusObjectManagerClientGetProxyTypeUserDataPropertyInfo), '("name", DBusObjectManagerClientNamePropertyInfo), '("name-owner", DBusObjectManagerClientNameOwnerPropertyInfo), '("object-path", DBusObjectManagerClientObjectPathPropertyInfo)]---- VVV Prop "connection"-   -- Type: TInterface "Gio" "DBusConnection"-   -- Flags: [PropertyReadable,PropertyWritable]--getDBusObjectManagerServerConnection :: (MonadIO m, DBusObjectManagerServerK o) => o -> m DBusConnection-getDBusObjectManagerServerConnection obj = liftIO $ getObjectPropertyObject obj "connection" DBusConnection--setDBusObjectManagerServerConnection :: (MonadIO m, DBusObjectManagerServerK o, DBusConnectionK a) => o -> a -> m ()-setDBusObjectManagerServerConnection obj val = liftIO $ setObjectPropertyObject obj "connection" val--constructDBusObjectManagerServerConnection :: (DBusConnectionK a) => a -> IO ([Char], GValue)-constructDBusObjectManagerServerConnection val = constructObjectPropertyObject "connection" val--data DBusObjectManagerServerConnectionPropertyInfo-instance AttrInfo DBusObjectManagerServerConnectionPropertyInfo where-    type AttrAllowedOps DBusObjectManagerServerConnectionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint DBusObjectManagerServerConnectionPropertyInfo = DBusConnectionK-    type AttrBaseTypeConstraint DBusObjectManagerServerConnectionPropertyInfo = DBusObjectManagerServerK-    type AttrGetType DBusObjectManagerServerConnectionPropertyInfo = DBusConnection-    type AttrLabel DBusObjectManagerServerConnectionPropertyInfo = "DBusObjectManagerServer::connection"-    attrGet _ = getDBusObjectManagerServerConnection-    attrSet _ = setDBusObjectManagerServerConnection-    attrConstruct _ = constructDBusObjectManagerServerConnection---- VVV Prop "object-path"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getDBusObjectManagerServerObjectPath :: (MonadIO m, DBusObjectManagerServerK o) => o -> m T.Text-getDBusObjectManagerServerObjectPath obj = liftIO $ getObjectPropertyString obj "object-path"--constructDBusObjectManagerServerObjectPath :: T.Text -> IO ([Char], GValue)-constructDBusObjectManagerServerObjectPath val = constructObjectPropertyString "object-path" val--data DBusObjectManagerServerObjectPathPropertyInfo-instance AttrInfo DBusObjectManagerServerObjectPathPropertyInfo where-    type AttrAllowedOps DBusObjectManagerServerObjectPathPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint DBusObjectManagerServerObjectPathPropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint DBusObjectManagerServerObjectPathPropertyInfo = DBusObjectManagerServerK-    type AttrGetType DBusObjectManagerServerObjectPathPropertyInfo = T.Text-    type AttrLabel DBusObjectManagerServerObjectPathPropertyInfo = "DBusObjectManagerServer::object-path"-    attrGet _ = getDBusObjectManagerServerObjectPath-    attrSet _ = undefined-    attrConstruct _ = constructDBusObjectManagerServerObjectPath--type instance AttributeList DBusObjectManagerServer = '[ '("connection", DBusObjectManagerServerConnectionPropertyInfo), '("object-path", DBusObjectManagerServerObjectPathPropertyInfo)]---- VVV Prop "g-connection"-   -- Type: TInterface "Gio" "DBusConnection"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getDBusObjectProxyGConnection :: (MonadIO m, DBusObjectProxyK o) => o -> m DBusConnection-getDBusObjectProxyGConnection obj = liftIO $ getObjectPropertyObject obj "g-connection" DBusConnection--constructDBusObjectProxyGConnection :: (DBusConnectionK a) => a -> IO ([Char], GValue)-constructDBusObjectProxyGConnection val = constructObjectPropertyObject "g-connection" val--data DBusObjectProxyGConnectionPropertyInfo-instance AttrInfo DBusObjectProxyGConnectionPropertyInfo where-    type AttrAllowedOps DBusObjectProxyGConnectionPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint DBusObjectProxyGConnectionPropertyInfo = DBusConnectionK-    type AttrBaseTypeConstraint DBusObjectProxyGConnectionPropertyInfo = DBusObjectProxyK-    type AttrGetType DBusObjectProxyGConnectionPropertyInfo = DBusConnection-    type AttrLabel DBusObjectProxyGConnectionPropertyInfo = "DBusObjectProxy::g-connection"-    attrGet _ = getDBusObjectProxyGConnection-    attrSet _ = undefined-    attrConstruct _ = constructDBusObjectProxyGConnection---- VVV Prop "g-object-path"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getDBusObjectProxyGObjectPath :: (MonadIO m, DBusObjectProxyK o) => o -> m T.Text-getDBusObjectProxyGObjectPath obj = liftIO $ getObjectPropertyString obj "g-object-path"--constructDBusObjectProxyGObjectPath :: T.Text -> IO ([Char], GValue)-constructDBusObjectProxyGObjectPath val = constructObjectPropertyString "g-object-path" val--data DBusObjectProxyGObjectPathPropertyInfo-instance AttrInfo DBusObjectProxyGObjectPathPropertyInfo where-    type AttrAllowedOps DBusObjectProxyGObjectPathPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint DBusObjectProxyGObjectPathPropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint DBusObjectProxyGObjectPathPropertyInfo = DBusObjectProxyK-    type AttrGetType DBusObjectProxyGObjectPathPropertyInfo = T.Text-    type AttrLabel DBusObjectProxyGObjectPathPropertyInfo = "DBusObjectProxy::g-object-path"-    attrGet _ = getDBusObjectProxyGObjectPath-    attrSet _ = undefined-    attrConstruct _ = constructDBusObjectProxyGObjectPath--type instance AttributeList DBusObjectProxy = '[ '("g-connection", DBusObjectProxyGConnectionPropertyInfo), '("g-object-path", DBusObjectProxyGObjectPathPropertyInfo)]---- VVV Prop "g-object-path"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]--getDBusObjectSkeletonGObjectPath :: (MonadIO m, DBusObjectSkeletonK o) => o -> m T.Text-getDBusObjectSkeletonGObjectPath obj = liftIO $ getObjectPropertyString obj "g-object-path"--setDBusObjectSkeletonGObjectPath :: (MonadIO m, DBusObjectSkeletonK o) => o -> T.Text -> m ()-setDBusObjectSkeletonGObjectPath obj val = liftIO $ setObjectPropertyString obj "g-object-path" val--constructDBusObjectSkeletonGObjectPath :: T.Text -> IO ([Char], GValue)-constructDBusObjectSkeletonGObjectPath val = constructObjectPropertyString "g-object-path" val--data DBusObjectSkeletonGObjectPathPropertyInfo-instance AttrInfo DBusObjectSkeletonGObjectPathPropertyInfo where-    type AttrAllowedOps DBusObjectSkeletonGObjectPathPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint DBusObjectSkeletonGObjectPathPropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint DBusObjectSkeletonGObjectPathPropertyInfo = DBusObjectSkeletonK-    type AttrGetType DBusObjectSkeletonGObjectPathPropertyInfo = T.Text-    type AttrLabel DBusObjectSkeletonGObjectPathPropertyInfo = "DBusObjectSkeleton::g-object-path"-    attrGet _ = getDBusObjectSkeletonGObjectPath-    attrSet _ = setDBusObjectSkeletonGObjectPath-    attrConstruct _ = constructDBusObjectSkeletonGObjectPath--type instance AttributeList DBusObjectSkeleton = '[ '("g-object-path", DBusObjectSkeletonGObjectPathPropertyInfo)]---- VVV Prop "g-bus-type"-   -- Type: TInterface "Gio" "BusType"-   -- Flags: [PropertyWritable,PropertyConstructOnly]--constructDBusProxyGBusType :: BusType -> IO ([Char], GValue)-constructDBusProxyGBusType val = constructObjectPropertyEnum "g-bus-type" val--data DBusProxyGBusTypePropertyInfo-instance AttrInfo DBusProxyGBusTypePropertyInfo where-    type AttrAllowedOps DBusProxyGBusTypePropertyInfo = '[ 'AttrConstruct]-    type AttrSetTypeConstraint DBusProxyGBusTypePropertyInfo = (~) BusType-    type AttrBaseTypeConstraint DBusProxyGBusTypePropertyInfo = DBusProxyK-    type AttrGetType DBusProxyGBusTypePropertyInfo = ()-    type AttrLabel DBusProxyGBusTypePropertyInfo = "DBusProxy::g-bus-type"-    attrGet _ = undefined-    attrSet _ = undefined-    attrConstruct _ = constructDBusProxyGBusType---- VVV Prop "g-connection"-   -- Type: TInterface "Gio" "DBusConnection"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getDBusProxyGConnection :: (MonadIO m, DBusProxyK o) => o -> m DBusConnection-getDBusProxyGConnection obj = liftIO $ getObjectPropertyObject obj "g-connection" DBusConnection--constructDBusProxyGConnection :: (DBusConnectionK a) => a -> IO ([Char], GValue)-constructDBusProxyGConnection val = constructObjectPropertyObject "g-connection" val--data DBusProxyGConnectionPropertyInfo-instance AttrInfo DBusProxyGConnectionPropertyInfo where-    type AttrAllowedOps DBusProxyGConnectionPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint DBusProxyGConnectionPropertyInfo = DBusConnectionK-    type AttrBaseTypeConstraint DBusProxyGConnectionPropertyInfo = DBusProxyK-    type AttrGetType DBusProxyGConnectionPropertyInfo = DBusConnection-    type AttrLabel DBusProxyGConnectionPropertyInfo = "DBusProxy::g-connection"-    attrGet _ = getDBusProxyGConnection-    attrSet _ = undefined-    attrConstruct _ = constructDBusProxyGConnection---- VVV Prop "g-default-timeout"-   -- Type: TBasicType TInt32-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]--getDBusProxyGDefaultTimeout :: (MonadIO m, DBusProxyK o) => o -> m Int32-getDBusProxyGDefaultTimeout obj = liftIO $ getObjectPropertyCInt obj "g-default-timeout"--setDBusProxyGDefaultTimeout :: (MonadIO m, DBusProxyK o) => o -> Int32 -> m ()-setDBusProxyGDefaultTimeout obj val = liftIO $ setObjectPropertyCInt obj "g-default-timeout" val--constructDBusProxyGDefaultTimeout :: Int32 -> IO ([Char], GValue)-constructDBusProxyGDefaultTimeout val = constructObjectPropertyCInt "g-default-timeout" val--data DBusProxyGDefaultTimeoutPropertyInfo-instance AttrInfo DBusProxyGDefaultTimeoutPropertyInfo where-    type AttrAllowedOps DBusProxyGDefaultTimeoutPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint DBusProxyGDefaultTimeoutPropertyInfo = (~) Int32-    type AttrBaseTypeConstraint DBusProxyGDefaultTimeoutPropertyInfo = DBusProxyK-    type AttrGetType DBusProxyGDefaultTimeoutPropertyInfo = Int32-    type AttrLabel DBusProxyGDefaultTimeoutPropertyInfo = "DBusProxy::g-default-timeout"-    attrGet _ = getDBusProxyGDefaultTimeout-    attrSet _ = setDBusProxyGDefaultTimeout-    attrConstruct _ = constructDBusProxyGDefaultTimeout---- VVV Prop "g-flags"-   -- Type: TInterface "Gio" "DBusProxyFlags"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getDBusProxyGFlags :: (MonadIO m, DBusProxyK o) => o -> m [DBusProxyFlags]-getDBusProxyGFlags obj = liftIO $ getObjectPropertyFlags obj "g-flags"--constructDBusProxyGFlags :: [DBusProxyFlags] -> IO ([Char], GValue)-constructDBusProxyGFlags val = constructObjectPropertyFlags "g-flags" val--data DBusProxyGFlagsPropertyInfo-instance AttrInfo DBusProxyGFlagsPropertyInfo where-    type AttrAllowedOps DBusProxyGFlagsPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint DBusProxyGFlagsPropertyInfo = (~) [DBusProxyFlags]-    type AttrBaseTypeConstraint DBusProxyGFlagsPropertyInfo = DBusProxyK-    type AttrGetType DBusProxyGFlagsPropertyInfo = [DBusProxyFlags]-    type AttrLabel DBusProxyGFlagsPropertyInfo = "DBusProxy::g-flags"-    attrGet _ = getDBusProxyGFlags-    attrSet _ = undefined-    attrConstruct _ = constructDBusProxyGFlags---- VVV Prop "g-interface-info"-   -- Type: TInterface "Gio" "DBusInterfaceInfo"-   -- Flags: [PropertyReadable,PropertyWritable]--getDBusProxyGInterfaceInfo :: (MonadIO m, DBusProxyK o) => o -> m DBusInterfaceInfo-getDBusProxyGInterfaceInfo obj = liftIO $ getObjectPropertyBoxed obj "g-interface-info" DBusInterfaceInfo--setDBusProxyGInterfaceInfo :: (MonadIO m, DBusProxyK o) => o -> DBusInterfaceInfo -> m ()-setDBusProxyGInterfaceInfo obj val = liftIO $ setObjectPropertyBoxed obj "g-interface-info" val--constructDBusProxyGInterfaceInfo :: DBusInterfaceInfo -> IO ([Char], GValue)-constructDBusProxyGInterfaceInfo val = constructObjectPropertyBoxed "g-interface-info" val--data DBusProxyGInterfaceInfoPropertyInfo-instance AttrInfo DBusProxyGInterfaceInfoPropertyInfo where-    type AttrAllowedOps DBusProxyGInterfaceInfoPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint DBusProxyGInterfaceInfoPropertyInfo = (~) DBusInterfaceInfo-    type AttrBaseTypeConstraint DBusProxyGInterfaceInfoPropertyInfo = DBusProxyK-    type AttrGetType DBusProxyGInterfaceInfoPropertyInfo = DBusInterfaceInfo-    type AttrLabel DBusProxyGInterfaceInfoPropertyInfo = "DBusProxy::g-interface-info"-    attrGet _ = getDBusProxyGInterfaceInfo-    attrSet _ = setDBusProxyGInterfaceInfo-    attrConstruct _ = constructDBusProxyGInterfaceInfo---- VVV Prop "g-interface-name"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getDBusProxyGInterfaceName :: (MonadIO m, DBusProxyK o) => o -> m T.Text-getDBusProxyGInterfaceName obj = liftIO $ getObjectPropertyString obj "g-interface-name"--constructDBusProxyGInterfaceName :: T.Text -> IO ([Char], GValue)-constructDBusProxyGInterfaceName val = constructObjectPropertyString "g-interface-name" val--data DBusProxyGInterfaceNamePropertyInfo-instance AttrInfo DBusProxyGInterfaceNamePropertyInfo where-    type AttrAllowedOps DBusProxyGInterfaceNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint DBusProxyGInterfaceNamePropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint DBusProxyGInterfaceNamePropertyInfo = DBusProxyK-    type AttrGetType DBusProxyGInterfaceNamePropertyInfo = T.Text-    type AttrLabel DBusProxyGInterfaceNamePropertyInfo = "DBusProxy::g-interface-name"-    attrGet _ = getDBusProxyGInterfaceName-    attrSet _ = undefined-    attrConstruct _ = constructDBusProxyGInterfaceName---- VVV Prop "g-name"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getDBusProxyGName :: (MonadIO m, DBusProxyK o) => o -> m T.Text-getDBusProxyGName obj = liftIO $ getObjectPropertyString obj "g-name"--constructDBusProxyGName :: T.Text -> IO ([Char], GValue)-constructDBusProxyGName val = constructObjectPropertyString "g-name" val--data DBusProxyGNamePropertyInfo-instance AttrInfo DBusProxyGNamePropertyInfo where-    type AttrAllowedOps DBusProxyGNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint DBusProxyGNamePropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint DBusProxyGNamePropertyInfo = DBusProxyK-    type AttrGetType DBusProxyGNamePropertyInfo = T.Text-    type AttrLabel DBusProxyGNamePropertyInfo = "DBusProxy::g-name"-    attrGet _ = getDBusProxyGName-    attrSet _ = undefined-    attrConstruct _ = constructDBusProxyGName---- VVV Prop "g-name-owner"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable]--getDBusProxyGNameOwner :: (MonadIO m, DBusProxyK o) => o -> m T.Text-getDBusProxyGNameOwner obj = liftIO $ getObjectPropertyString obj "g-name-owner"--data DBusProxyGNameOwnerPropertyInfo-instance AttrInfo DBusProxyGNameOwnerPropertyInfo where-    type AttrAllowedOps DBusProxyGNameOwnerPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint DBusProxyGNameOwnerPropertyInfo = (~) ()-    type AttrBaseTypeConstraint DBusProxyGNameOwnerPropertyInfo = DBusProxyK-    type AttrGetType DBusProxyGNameOwnerPropertyInfo = T.Text-    type AttrLabel DBusProxyGNameOwnerPropertyInfo = "DBusProxy::g-name-owner"-    attrGet _ = getDBusProxyGNameOwner-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "g-object-path"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getDBusProxyGObjectPath :: (MonadIO m, DBusProxyK o) => o -> m T.Text-getDBusProxyGObjectPath obj = liftIO $ getObjectPropertyString obj "g-object-path"--constructDBusProxyGObjectPath :: T.Text -> IO ([Char], GValue)-constructDBusProxyGObjectPath val = constructObjectPropertyString "g-object-path" val--data DBusProxyGObjectPathPropertyInfo-instance AttrInfo DBusProxyGObjectPathPropertyInfo where-    type AttrAllowedOps DBusProxyGObjectPathPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint DBusProxyGObjectPathPropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint DBusProxyGObjectPathPropertyInfo = DBusProxyK-    type AttrGetType DBusProxyGObjectPathPropertyInfo = T.Text-    type AttrLabel DBusProxyGObjectPathPropertyInfo = "DBusProxy::g-object-path"-    attrGet _ = getDBusProxyGObjectPath-    attrSet _ = undefined-    attrConstruct _ = constructDBusProxyGObjectPath--type instance AttributeList DBusProxy = '[ '("g-bus-type", DBusProxyGBusTypePropertyInfo), '("g-connection", DBusProxyGConnectionPropertyInfo), '("g-default-timeout", DBusProxyGDefaultTimeoutPropertyInfo), '("g-flags", DBusProxyGFlagsPropertyInfo), '("g-interface-info", DBusProxyGInterfaceInfoPropertyInfo), '("g-interface-name", DBusProxyGInterfaceNamePropertyInfo), '("g-name", DBusProxyGNamePropertyInfo), '("g-name-owner", DBusProxyGNameOwnerPropertyInfo), '("g-object-path", DBusProxyGObjectPathPropertyInfo)]---- VVV Prop "active"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable]--getDBusServerActive :: (MonadIO m, DBusServerK o) => o -> m Bool-getDBusServerActive obj = liftIO $ getObjectPropertyBool obj "active"--data DBusServerActivePropertyInfo-instance AttrInfo DBusServerActivePropertyInfo where-    type AttrAllowedOps DBusServerActivePropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint DBusServerActivePropertyInfo = (~) ()-    type AttrBaseTypeConstraint DBusServerActivePropertyInfo = DBusServerK-    type AttrGetType DBusServerActivePropertyInfo = Bool-    type AttrLabel DBusServerActivePropertyInfo = "DBusServer::active"-    attrGet _ = getDBusServerActive-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "address"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getDBusServerAddress :: (MonadIO m, DBusServerK o) => o -> m T.Text-getDBusServerAddress obj = liftIO $ getObjectPropertyString obj "address"--constructDBusServerAddress :: T.Text -> IO ([Char], GValue)-constructDBusServerAddress val = constructObjectPropertyString "address" val--data DBusServerAddressPropertyInfo-instance AttrInfo DBusServerAddressPropertyInfo where-    type AttrAllowedOps DBusServerAddressPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint DBusServerAddressPropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint DBusServerAddressPropertyInfo = DBusServerK-    type AttrGetType DBusServerAddressPropertyInfo = T.Text-    type AttrLabel DBusServerAddressPropertyInfo = "DBusServer::address"-    attrGet _ = getDBusServerAddress-    attrSet _ = undefined-    attrConstruct _ = constructDBusServerAddress---- VVV Prop "authentication-observer"-   -- Type: TInterface "Gio" "DBusAuthObserver"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getDBusServerAuthenticationObserver :: (MonadIO m, DBusServerK o) => o -> m DBusAuthObserver-getDBusServerAuthenticationObserver obj = liftIO $ getObjectPropertyObject obj "authentication-observer" DBusAuthObserver--constructDBusServerAuthenticationObserver :: (DBusAuthObserverK a) => a -> IO ([Char], GValue)-constructDBusServerAuthenticationObserver val = constructObjectPropertyObject "authentication-observer" val--data DBusServerAuthenticationObserverPropertyInfo-instance AttrInfo DBusServerAuthenticationObserverPropertyInfo where-    type AttrAllowedOps DBusServerAuthenticationObserverPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint DBusServerAuthenticationObserverPropertyInfo = DBusAuthObserverK-    type AttrBaseTypeConstraint DBusServerAuthenticationObserverPropertyInfo = DBusServerK-    type AttrGetType DBusServerAuthenticationObserverPropertyInfo = DBusAuthObserver-    type AttrLabel DBusServerAuthenticationObserverPropertyInfo = "DBusServer::authentication-observer"-    attrGet _ = getDBusServerAuthenticationObserver-    attrSet _ = undefined-    attrConstruct _ = constructDBusServerAuthenticationObserver---- VVV Prop "client-address"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable]--getDBusServerClientAddress :: (MonadIO m, DBusServerK o) => o -> m T.Text-getDBusServerClientAddress obj = liftIO $ getObjectPropertyString obj "client-address"--data DBusServerClientAddressPropertyInfo-instance AttrInfo DBusServerClientAddressPropertyInfo where-    type AttrAllowedOps DBusServerClientAddressPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint DBusServerClientAddressPropertyInfo = (~) ()-    type AttrBaseTypeConstraint DBusServerClientAddressPropertyInfo = DBusServerK-    type AttrGetType DBusServerClientAddressPropertyInfo = T.Text-    type AttrLabel DBusServerClientAddressPropertyInfo = "DBusServer::client-address"-    attrGet _ = getDBusServerClientAddress-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "flags"-   -- Type: TInterface "Gio" "DBusServerFlags"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getDBusServerFlags :: (MonadIO m, DBusServerK o) => o -> m [DBusServerFlags]-getDBusServerFlags obj = liftIO $ getObjectPropertyFlags obj "flags"--constructDBusServerFlags :: [DBusServerFlags] -> IO ([Char], GValue)-constructDBusServerFlags val = constructObjectPropertyFlags "flags" val--data DBusServerFlagsPropertyInfo-instance AttrInfo DBusServerFlagsPropertyInfo where-    type AttrAllowedOps DBusServerFlagsPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint DBusServerFlagsPropertyInfo = (~) [DBusServerFlags]-    type AttrBaseTypeConstraint DBusServerFlagsPropertyInfo = DBusServerK-    type AttrGetType DBusServerFlagsPropertyInfo = [DBusServerFlags]-    type AttrLabel DBusServerFlagsPropertyInfo = "DBusServer::flags"-    attrGet _ = getDBusServerFlags-    attrSet _ = undefined-    attrConstruct _ = constructDBusServerFlags---- VVV Prop "guid"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getDBusServerGuid :: (MonadIO m, DBusServerK o) => o -> m T.Text-getDBusServerGuid obj = liftIO $ getObjectPropertyString obj "guid"--constructDBusServerGuid :: T.Text -> IO ([Char], GValue)-constructDBusServerGuid val = constructObjectPropertyString "guid" val--data DBusServerGuidPropertyInfo-instance AttrInfo DBusServerGuidPropertyInfo where-    type AttrAllowedOps DBusServerGuidPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint DBusServerGuidPropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint DBusServerGuidPropertyInfo = DBusServerK-    type AttrGetType DBusServerGuidPropertyInfo = T.Text-    type AttrLabel DBusServerGuidPropertyInfo = "DBusServer::guid"-    attrGet _ = getDBusServerGuid-    attrSet _ = undefined-    attrConstruct _ = constructDBusServerGuid--type instance AttributeList DBusServer = '[ '("active", DBusServerActivePropertyInfo), '("address", DBusServerAddressPropertyInfo), '("authentication-observer", DBusServerAuthenticationObserverPropertyInfo), '("client-address", DBusServerClientAddressPropertyInfo), '("flags", DBusServerFlagsPropertyInfo), '("guid", DBusServerGuidPropertyInfo)]---- VVV Prop "byte-order"-   -- Type: TInterface "Gio" "DataStreamByteOrder"-   -- Flags: [PropertyReadable,PropertyWritable]--getDataInputStreamByteOrder :: (MonadIO m, DataInputStreamK o) => o -> m DataStreamByteOrder-getDataInputStreamByteOrder obj = liftIO $ getObjectPropertyEnum obj "byte-order"--setDataInputStreamByteOrder :: (MonadIO m, DataInputStreamK o) => o -> DataStreamByteOrder -> m ()-setDataInputStreamByteOrder obj val = liftIO $ setObjectPropertyEnum obj "byte-order" val--constructDataInputStreamByteOrder :: DataStreamByteOrder -> IO ([Char], GValue)-constructDataInputStreamByteOrder val = constructObjectPropertyEnum "byte-order" val--data DataInputStreamByteOrderPropertyInfo-instance AttrInfo DataInputStreamByteOrderPropertyInfo where-    type AttrAllowedOps DataInputStreamByteOrderPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint DataInputStreamByteOrderPropertyInfo = (~) DataStreamByteOrder-    type AttrBaseTypeConstraint DataInputStreamByteOrderPropertyInfo = DataInputStreamK-    type AttrGetType DataInputStreamByteOrderPropertyInfo = DataStreamByteOrder-    type AttrLabel DataInputStreamByteOrderPropertyInfo = "DataInputStream::byte-order"-    attrGet _ = getDataInputStreamByteOrder-    attrSet _ = setDataInputStreamByteOrder-    attrConstruct _ = constructDataInputStreamByteOrder---- VVV Prop "newline-type"-   -- Type: TInterface "Gio" "DataStreamNewlineType"-   -- Flags: [PropertyReadable,PropertyWritable]--getDataInputStreamNewlineType :: (MonadIO m, DataInputStreamK o) => o -> m DataStreamNewlineType-getDataInputStreamNewlineType obj = liftIO $ getObjectPropertyEnum obj "newline-type"--setDataInputStreamNewlineType :: (MonadIO m, DataInputStreamK o) => o -> DataStreamNewlineType -> m ()-setDataInputStreamNewlineType obj val = liftIO $ setObjectPropertyEnum obj "newline-type" val--constructDataInputStreamNewlineType :: DataStreamNewlineType -> IO ([Char], GValue)-constructDataInputStreamNewlineType val = constructObjectPropertyEnum "newline-type" val--data DataInputStreamNewlineTypePropertyInfo-instance AttrInfo DataInputStreamNewlineTypePropertyInfo where-    type AttrAllowedOps DataInputStreamNewlineTypePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint DataInputStreamNewlineTypePropertyInfo = (~) DataStreamNewlineType-    type AttrBaseTypeConstraint DataInputStreamNewlineTypePropertyInfo = DataInputStreamK-    type AttrGetType DataInputStreamNewlineTypePropertyInfo = DataStreamNewlineType-    type AttrLabel DataInputStreamNewlineTypePropertyInfo = "DataInputStream::newline-type"-    attrGet _ = getDataInputStreamNewlineType-    attrSet _ = setDataInputStreamNewlineType-    attrConstruct _ = constructDataInputStreamNewlineType--type instance AttributeList DataInputStream = '[ '("base-stream", FilterInputStreamBaseStreamPropertyInfo), '("buffer-size", BufferedInputStreamBufferSizePropertyInfo), '("byte-order", DataInputStreamByteOrderPropertyInfo), '("close-base-stream", FilterInputStreamCloseBaseStreamPropertyInfo), '("newline-type", DataInputStreamNewlineTypePropertyInfo)]---- VVV Prop "byte-order"-   -- Type: TInterface "Gio" "DataStreamByteOrder"-   -- Flags: [PropertyReadable,PropertyWritable]--getDataOutputStreamByteOrder :: (MonadIO m, DataOutputStreamK o) => o -> m DataStreamByteOrder-getDataOutputStreamByteOrder obj = liftIO $ getObjectPropertyEnum obj "byte-order"--setDataOutputStreamByteOrder :: (MonadIO m, DataOutputStreamK o) => o -> DataStreamByteOrder -> m ()-setDataOutputStreamByteOrder obj val = liftIO $ setObjectPropertyEnum obj "byte-order" val--constructDataOutputStreamByteOrder :: DataStreamByteOrder -> IO ([Char], GValue)-constructDataOutputStreamByteOrder val = constructObjectPropertyEnum "byte-order" val--data DataOutputStreamByteOrderPropertyInfo-instance AttrInfo DataOutputStreamByteOrderPropertyInfo where-    type AttrAllowedOps DataOutputStreamByteOrderPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint DataOutputStreamByteOrderPropertyInfo = (~) DataStreamByteOrder-    type AttrBaseTypeConstraint DataOutputStreamByteOrderPropertyInfo = DataOutputStreamK-    type AttrGetType DataOutputStreamByteOrderPropertyInfo = DataStreamByteOrder-    type AttrLabel DataOutputStreamByteOrderPropertyInfo = "DataOutputStream::byte-order"-    attrGet _ = getDataOutputStreamByteOrder-    attrSet _ = setDataOutputStreamByteOrder-    attrConstruct _ = constructDataOutputStreamByteOrder--type instance AttributeList DataOutputStream = '[ '("base-stream", FilterOutputStreamBaseStreamPropertyInfo), '("byte-order", DataOutputStreamByteOrderPropertyInfo), '("close-base-stream", FilterOutputStreamCloseBaseStreamPropertyInfo)]---- VVV Prop "filename"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getDesktopAppInfoFilename :: (MonadIO m, DesktopAppInfoK o) => o -> m T.Text-getDesktopAppInfoFilename obj = liftIO $ getObjectPropertyString obj "filename"--constructDesktopAppInfoFilename :: T.Text -> IO ([Char], GValue)-constructDesktopAppInfoFilename val = constructObjectPropertyString "filename" val--data DesktopAppInfoFilenamePropertyInfo-instance AttrInfo DesktopAppInfoFilenamePropertyInfo where-    type AttrAllowedOps DesktopAppInfoFilenamePropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint DesktopAppInfoFilenamePropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint DesktopAppInfoFilenamePropertyInfo = DesktopAppInfoK-    type AttrGetType DesktopAppInfoFilenamePropertyInfo = T.Text-    type AttrLabel DesktopAppInfoFilenamePropertyInfo = "DesktopAppInfo::filename"-    attrGet _ = getDesktopAppInfoFilename-    attrSet _ = undefined-    attrConstruct _ = constructDesktopAppInfoFilename--type instance AttributeList DesktopAppInfo = '[ '("filename", DesktopAppInfoFilenamePropertyInfo)]--type instance AttributeList DesktopAppInfoLookup = '[ ]--type instance AttributeList Drive = '[ ]---- VVV Prop "icon"-   -- Type: TInterface "GObject" "Object"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getEmblemIcon :: (MonadIO m, EmblemK o) => o -> m GObject.Object-getEmblemIcon obj = liftIO $ getObjectPropertyObject obj "icon" GObject.Object--constructEmblemIcon :: (GObject.ObjectK a) => a -> IO ([Char], GValue)-constructEmblemIcon val = constructObjectPropertyObject "icon" val--data EmblemIconPropertyInfo-instance AttrInfo EmblemIconPropertyInfo where-    type AttrAllowedOps EmblemIconPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint EmblemIconPropertyInfo = GObject.ObjectK-    type AttrBaseTypeConstraint EmblemIconPropertyInfo = EmblemK-    type AttrGetType EmblemIconPropertyInfo = GObject.Object-    type AttrLabel EmblemIconPropertyInfo = "Emblem::icon"-    attrGet _ = getEmblemIcon-    attrSet _ = undefined-    attrConstruct _ = constructEmblemIcon---- VVV Prop "origin"-   -- Type: TInterface "Gio" "EmblemOrigin"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getEmblemOrigin :: (MonadIO m, EmblemK o) => o -> m EmblemOrigin-getEmblemOrigin obj = liftIO $ getObjectPropertyEnum obj "origin"--constructEmblemOrigin :: EmblemOrigin -> IO ([Char], GValue)-constructEmblemOrigin val = constructObjectPropertyEnum "origin" val--data EmblemOriginPropertyInfo-instance AttrInfo EmblemOriginPropertyInfo where-    type AttrAllowedOps EmblemOriginPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint EmblemOriginPropertyInfo = (~) EmblemOrigin-    type AttrBaseTypeConstraint EmblemOriginPropertyInfo = EmblemK-    type AttrGetType EmblemOriginPropertyInfo = EmblemOrigin-    type AttrLabel EmblemOriginPropertyInfo = "Emblem::origin"-    attrGet _ = getEmblemOrigin-    attrSet _ = undefined-    attrConstruct _ = constructEmblemOrigin--type instance AttributeList Emblem = '[ '("icon", EmblemIconPropertyInfo), '("origin", EmblemOriginPropertyInfo)]---- VVV Prop "gicon"-   -- Type: TInterface "Gio" "Icon"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getEmblemedIconGicon :: (MonadIO m, EmblemedIconK o) => o -> m Icon-getEmblemedIconGicon obj = liftIO $ getObjectPropertyObject obj "gicon" Icon--constructEmblemedIconGicon :: (IconK a) => a -> IO ([Char], GValue)-constructEmblemedIconGicon val = constructObjectPropertyObject "gicon" val--data EmblemedIconGiconPropertyInfo-instance AttrInfo EmblemedIconGiconPropertyInfo where-    type AttrAllowedOps EmblemedIconGiconPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint EmblemedIconGiconPropertyInfo = IconK-    type AttrBaseTypeConstraint EmblemedIconGiconPropertyInfo = EmblemedIconK-    type AttrGetType EmblemedIconGiconPropertyInfo = Icon-    type AttrLabel EmblemedIconGiconPropertyInfo = "EmblemedIcon::gicon"-    attrGet _ = getEmblemedIconGicon-    attrSet _ = undefined-    attrConstruct _ = constructEmblemedIconGicon--type instance AttributeList EmblemedIcon = '[ '("gicon", EmblemedIconGiconPropertyInfo)]--type instance AttributeList File = '[ ]--type instance AttributeList FileDescriptorBased = '[ ]---- VVV Prop "container"-   -- Type: TInterface "Gio" "File"-   -- Flags: [PropertyWritable,PropertyConstructOnly]--constructFileEnumeratorContainer :: (FileK a) => a -> IO ([Char], GValue)-constructFileEnumeratorContainer val = constructObjectPropertyObject "container" val--data FileEnumeratorContainerPropertyInfo-instance AttrInfo FileEnumeratorContainerPropertyInfo where-    type AttrAllowedOps FileEnumeratorContainerPropertyInfo = '[ 'AttrConstruct]-    type AttrSetTypeConstraint FileEnumeratorContainerPropertyInfo = FileK-    type AttrBaseTypeConstraint FileEnumeratorContainerPropertyInfo = FileEnumeratorK-    type AttrGetType FileEnumeratorContainerPropertyInfo = ()-    type AttrLabel FileEnumeratorContainerPropertyInfo = "FileEnumerator::container"-    attrGet _ = undefined-    attrSet _ = undefined-    attrConstruct _ = constructFileEnumeratorContainer--type instance AttributeList FileEnumerator = '[ '("container", FileEnumeratorContainerPropertyInfo)]--type instance AttributeList FileIOStream = '[ '("closed", IOStreamClosedPropertyInfo), '("input-stream", IOStreamInputStreamPropertyInfo), '("output-stream", IOStreamOutputStreamPropertyInfo)]---- VVV Prop "file"-   -- Type: TInterface "Gio" "File"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getFileIconFile :: (MonadIO m, FileIconK o) => o -> m File-getFileIconFile obj = liftIO $ getObjectPropertyObject obj "file" File--constructFileIconFile :: (FileK a) => a -> IO ([Char], GValue)-constructFileIconFile val = constructObjectPropertyObject "file" val--data FileIconFilePropertyInfo-instance AttrInfo FileIconFilePropertyInfo where-    type AttrAllowedOps FileIconFilePropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint FileIconFilePropertyInfo = FileK-    type AttrBaseTypeConstraint FileIconFilePropertyInfo = FileIconK-    type AttrGetType FileIconFilePropertyInfo = File-    type AttrLabel FileIconFilePropertyInfo = "FileIcon::file"-    attrGet _ = getFileIconFile-    attrSet _ = undefined-    attrConstruct _ = constructFileIconFile--type instance AttributeList FileIcon = '[ '("file", FileIconFilePropertyInfo)]--type instance AttributeList FileInfo = '[ ]--type instance AttributeList FileInputStream = '[ ]---- VVV Prop "cancelled"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable]--getFileMonitorCancelled :: (MonadIO m, FileMonitorK o) => o -> m Bool-getFileMonitorCancelled obj = liftIO $ getObjectPropertyBool obj "cancelled"--data FileMonitorCancelledPropertyInfo-instance AttrInfo FileMonitorCancelledPropertyInfo where-    type AttrAllowedOps FileMonitorCancelledPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint FileMonitorCancelledPropertyInfo = (~) ()-    type AttrBaseTypeConstraint FileMonitorCancelledPropertyInfo = FileMonitorK-    type AttrGetType FileMonitorCancelledPropertyInfo = Bool-    type AttrLabel FileMonitorCancelledPropertyInfo = "FileMonitor::cancelled"-    attrGet _ = getFileMonitorCancelled-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "rate-limit"-   -- Type: TBasicType TInt32-   -- Flags: [PropertyReadable,PropertyWritable]--getFileMonitorRateLimit :: (MonadIO m, FileMonitorK o) => o -> m Int32-getFileMonitorRateLimit obj = liftIO $ getObjectPropertyCInt obj "rate-limit"--setFileMonitorRateLimit :: (MonadIO m, FileMonitorK o) => o -> Int32 -> m ()-setFileMonitorRateLimit obj val = liftIO $ setObjectPropertyCInt obj "rate-limit" val--constructFileMonitorRateLimit :: Int32 -> IO ([Char], GValue)-constructFileMonitorRateLimit val = constructObjectPropertyCInt "rate-limit" val--data FileMonitorRateLimitPropertyInfo-instance AttrInfo FileMonitorRateLimitPropertyInfo where-    type AttrAllowedOps FileMonitorRateLimitPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint FileMonitorRateLimitPropertyInfo = (~) Int32-    type AttrBaseTypeConstraint FileMonitorRateLimitPropertyInfo = FileMonitorK-    type AttrGetType FileMonitorRateLimitPropertyInfo = Int32-    type AttrLabel FileMonitorRateLimitPropertyInfo = "FileMonitor::rate-limit"-    attrGet _ = getFileMonitorRateLimit-    attrSet _ = setFileMonitorRateLimit-    attrConstruct _ = constructFileMonitorRateLimit--type instance AttributeList FileMonitor = '[ '("cancelled", FileMonitorCancelledPropertyInfo), '("rate-limit", FileMonitorRateLimitPropertyInfo)]--type instance AttributeList FileOutputStream = '[ ]--type instance AttributeList FilenameCompleter = '[ ]---- VVV Prop "base-stream"-   -- Type: TInterface "Gio" "InputStream"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getFilterInputStreamBaseStream :: (MonadIO m, FilterInputStreamK o) => o -> m InputStream-getFilterInputStreamBaseStream obj = liftIO $ getObjectPropertyObject obj "base-stream" InputStream--constructFilterInputStreamBaseStream :: (InputStreamK a) => a -> IO ([Char], GValue)-constructFilterInputStreamBaseStream val = constructObjectPropertyObject "base-stream" val--data FilterInputStreamBaseStreamPropertyInfo-instance AttrInfo FilterInputStreamBaseStreamPropertyInfo where-    type AttrAllowedOps FilterInputStreamBaseStreamPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint FilterInputStreamBaseStreamPropertyInfo = InputStreamK-    type AttrBaseTypeConstraint FilterInputStreamBaseStreamPropertyInfo = FilterInputStreamK-    type AttrGetType FilterInputStreamBaseStreamPropertyInfo = InputStream-    type AttrLabel FilterInputStreamBaseStreamPropertyInfo = "FilterInputStream::base-stream"-    attrGet _ = getFilterInputStreamBaseStream-    attrSet _ = undefined-    attrConstruct _ = constructFilterInputStreamBaseStream---- VVV Prop "close-base-stream"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]--getFilterInputStreamCloseBaseStream :: (MonadIO m, FilterInputStreamK o) => o -> m Bool-getFilterInputStreamCloseBaseStream obj = liftIO $ getObjectPropertyBool obj "close-base-stream"--setFilterInputStreamCloseBaseStream :: (MonadIO m, FilterInputStreamK o) => o -> Bool -> m ()-setFilterInputStreamCloseBaseStream obj val = liftIO $ setObjectPropertyBool obj "close-base-stream" val--constructFilterInputStreamCloseBaseStream :: Bool -> IO ([Char], GValue)-constructFilterInputStreamCloseBaseStream val = constructObjectPropertyBool "close-base-stream" val--data FilterInputStreamCloseBaseStreamPropertyInfo-instance AttrInfo FilterInputStreamCloseBaseStreamPropertyInfo where-    type AttrAllowedOps FilterInputStreamCloseBaseStreamPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint FilterInputStreamCloseBaseStreamPropertyInfo = (~) Bool-    type AttrBaseTypeConstraint FilterInputStreamCloseBaseStreamPropertyInfo = FilterInputStreamK-    type AttrGetType FilterInputStreamCloseBaseStreamPropertyInfo = Bool-    type AttrLabel FilterInputStreamCloseBaseStreamPropertyInfo = "FilterInputStream::close-base-stream"-    attrGet _ = getFilterInputStreamCloseBaseStream-    attrSet _ = setFilterInputStreamCloseBaseStream-    attrConstruct _ = constructFilterInputStreamCloseBaseStream--type instance AttributeList FilterInputStream = '[ '("base-stream", FilterInputStreamBaseStreamPropertyInfo), '("close-base-stream", FilterInputStreamCloseBaseStreamPropertyInfo)]---- VVV Prop "base-stream"-   -- Type: TInterface "Gio" "OutputStream"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getFilterOutputStreamBaseStream :: (MonadIO m, FilterOutputStreamK o) => o -> m OutputStream-getFilterOutputStreamBaseStream obj = liftIO $ getObjectPropertyObject obj "base-stream" OutputStream--constructFilterOutputStreamBaseStream :: (OutputStreamK a) => a -> IO ([Char], GValue)-constructFilterOutputStreamBaseStream val = constructObjectPropertyObject "base-stream" val--data FilterOutputStreamBaseStreamPropertyInfo-instance AttrInfo FilterOutputStreamBaseStreamPropertyInfo where-    type AttrAllowedOps FilterOutputStreamBaseStreamPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint FilterOutputStreamBaseStreamPropertyInfo = OutputStreamK-    type AttrBaseTypeConstraint FilterOutputStreamBaseStreamPropertyInfo = FilterOutputStreamK-    type AttrGetType FilterOutputStreamBaseStreamPropertyInfo = OutputStream-    type AttrLabel FilterOutputStreamBaseStreamPropertyInfo = "FilterOutputStream::base-stream"-    attrGet _ = getFilterOutputStreamBaseStream-    attrSet _ = undefined-    attrConstruct _ = constructFilterOutputStreamBaseStream---- VVV Prop "close-base-stream"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getFilterOutputStreamCloseBaseStream :: (MonadIO m, FilterOutputStreamK o) => o -> m Bool-getFilterOutputStreamCloseBaseStream obj = liftIO $ getObjectPropertyBool obj "close-base-stream"--constructFilterOutputStreamCloseBaseStream :: Bool -> IO ([Char], GValue)-constructFilterOutputStreamCloseBaseStream val = constructObjectPropertyBool "close-base-stream" val--data FilterOutputStreamCloseBaseStreamPropertyInfo-instance AttrInfo FilterOutputStreamCloseBaseStreamPropertyInfo where-    type AttrAllowedOps FilterOutputStreamCloseBaseStreamPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint FilterOutputStreamCloseBaseStreamPropertyInfo = (~) Bool-    type AttrBaseTypeConstraint FilterOutputStreamCloseBaseStreamPropertyInfo = FilterOutputStreamK-    type AttrGetType FilterOutputStreamCloseBaseStreamPropertyInfo = Bool-    type AttrLabel FilterOutputStreamCloseBaseStreamPropertyInfo = "FilterOutputStream::close-base-stream"-    attrGet _ = getFilterOutputStreamCloseBaseStream-    attrSet _ = undefined-    attrConstruct _ = constructFilterOutputStreamCloseBaseStream--type instance AttributeList FilterOutputStream = '[ '("base-stream", FilterOutputStreamBaseStreamPropertyInfo), '("close-base-stream", FilterOutputStreamCloseBaseStreamPropertyInfo)]---- VVV Prop "closed"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable]--getIOStreamClosed :: (MonadIO m, IOStreamK o) => o -> m Bool-getIOStreamClosed obj = liftIO $ getObjectPropertyBool obj "closed"--data IOStreamClosedPropertyInfo-instance AttrInfo IOStreamClosedPropertyInfo where-    type AttrAllowedOps IOStreamClosedPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint IOStreamClosedPropertyInfo = (~) ()-    type AttrBaseTypeConstraint IOStreamClosedPropertyInfo = IOStreamK-    type AttrGetType IOStreamClosedPropertyInfo = Bool-    type AttrLabel IOStreamClosedPropertyInfo = "IOStream::closed"-    attrGet _ = getIOStreamClosed-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "input-stream"-   -- Type: TInterface "Gio" "InputStream"-   -- Flags: [PropertyReadable]--getIOStreamInputStream :: (MonadIO m, IOStreamK o) => o -> m InputStream-getIOStreamInputStream obj = liftIO $ getObjectPropertyObject obj "input-stream" InputStream--data IOStreamInputStreamPropertyInfo-instance AttrInfo IOStreamInputStreamPropertyInfo where-    type AttrAllowedOps IOStreamInputStreamPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint IOStreamInputStreamPropertyInfo = (~) ()-    type AttrBaseTypeConstraint IOStreamInputStreamPropertyInfo = IOStreamK-    type AttrGetType IOStreamInputStreamPropertyInfo = InputStream-    type AttrLabel IOStreamInputStreamPropertyInfo = "IOStream::input-stream"-    attrGet _ = getIOStreamInputStream-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "output-stream"-   -- Type: TInterface "Gio" "OutputStream"-   -- Flags: [PropertyReadable]--getIOStreamOutputStream :: (MonadIO m, IOStreamK o) => o -> m OutputStream-getIOStreamOutputStream obj = liftIO $ getObjectPropertyObject obj "output-stream" OutputStream--data IOStreamOutputStreamPropertyInfo-instance AttrInfo IOStreamOutputStreamPropertyInfo where-    type AttrAllowedOps IOStreamOutputStreamPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint IOStreamOutputStreamPropertyInfo = (~) ()-    type AttrBaseTypeConstraint IOStreamOutputStreamPropertyInfo = IOStreamK-    type AttrGetType IOStreamOutputStreamPropertyInfo = OutputStream-    type AttrLabel IOStreamOutputStreamPropertyInfo = "IOStream::output-stream"-    attrGet _ = getIOStreamOutputStream-    attrSet _ = undefined-    attrConstruct _ = undefined--type instance AttributeList IOStream = '[ '("closed", IOStreamClosedPropertyInfo), '("input-stream", IOStreamInputStreamPropertyInfo), '("output-stream", IOStreamOutputStreamPropertyInfo)]--type instance AttributeList Icon = '[ ]---- VVV Prop "bytes"-   -- Type: TBasicType TVoid-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getInetAddressBytes :: (MonadIO m, InetAddressK o) => o -> m (Ptr ())-getInetAddressBytes obj = liftIO $ getObjectPropertyPtr obj "bytes"--constructInetAddressBytes :: (Ptr ()) -> IO ([Char], GValue)-constructInetAddressBytes val = constructObjectPropertyPtr "bytes" val--data InetAddressBytesPropertyInfo-instance AttrInfo InetAddressBytesPropertyInfo where-    type AttrAllowedOps InetAddressBytesPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint InetAddressBytesPropertyInfo = (~) (Ptr ())-    type AttrBaseTypeConstraint InetAddressBytesPropertyInfo = InetAddressK-    type AttrGetType InetAddressBytesPropertyInfo = (Ptr ())-    type AttrLabel InetAddressBytesPropertyInfo = "InetAddress::bytes"-    attrGet _ = getInetAddressBytes-    attrSet _ = undefined-    attrConstruct _ = constructInetAddressBytes---- VVV Prop "family"-   -- Type: TInterface "Gio" "SocketFamily"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getInetAddressFamily :: (MonadIO m, InetAddressK o) => o -> m SocketFamily-getInetAddressFamily obj = liftIO $ getObjectPropertyEnum obj "family"--constructInetAddressFamily :: SocketFamily -> IO ([Char], GValue)-constructInetAddressFamily val = constructObjectPropertyEnum "family" val--data InetAddressFamilyPropertyInfo-instance AttrInfo InetAddressFamilyPropertyInfo where-    type AttrAllowedOps InetAddressFamilyPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint InetAddressFamilyPropertyInfo = (~) SocketFamily-    type AttrBaseTypeConstraint InetAddressFamilyPropertyInfo = InetAddressK-    type AttrGetType InetAddressFamilyPropertyInfo = SocketFamily-    type AttrLabel InetAddressFamilyPropertyInfo = "InetAddress::family"-    attrGet _ = getInetAddressFamily-    attrSet _ = undefined-    attrConstruct _ = constructInetAddressFamily---- VVV Prop "is-any"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable]--getInetAddressIsAny :: (MonadIO m, InetAddressK o) => o -> m Bool-getInetAddressIsAny obj = liftIO $ getObjectPropertyBool obj "is-any"--data InetAddressIsAnyPropertyInfo-instance AttrInfo InetAddressIsAnyPropertyInfo where-    type AttrAllowedOps InetAddressIsAnyPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint InetAddressIsAnyPropertyInfo = (~) ()-    type AttrBaseTypeConstraint InetAddressIsAnyPropertyInfo = InetAddressK-    type AttrGetType InetAddressIsAnyPropertyInfo = Bool-    type AttrLabel InetAddressIsAnyPropertyInfo = "InetAddress::is-any"-    attrGet _ = getInetAddressIsAny-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "is-link-local"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable]--getInetAddressIsLinkLocal :: (MonadIO m, InetAddressK o) => o -> m Bool-getInetAddressIsLinkLocal obj = liftIO $ getObjectPropertyBool obj "is-link-local"--data InetAddressIsLinkLocalPropertyInfo-instance AttrInfo InetAddressIsLinkLocalPropertyInfo where-    type AttrAllowedOps InetAddressIsLinkLocalPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint InetAddressIsLinkLocalPropertyInfo = (~) ()-    type AttrBaseTypeConstraint InetAddressIsLinkLocalPropertyInfo = InetAddressK-    type AttrGetType InetAddressIsLinkLocalPropertyInfo = Bool-    type AttrLabel InetAddressIsLinkLocalPropertyInfo = "InetAddress::is-link-local"-    attrGet _ = getInetAddressIsLinkLocal-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "is-loopback"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable]--getInetAddressIsLoopback :: (MonadIO m, InetAddressK o) => o -> m Bool-getInetAddressIsLoopback obj = liftIO $ getObjectPropertyBool obj "is-loopback"--data InetAddressIsLoopbackPropertyInfo-instance AttrInfo InetAddressIsLoopbackPropertyInfo where-    type AttrAllowedOps InetAddressIsLoopbackPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint InetAddressIsLoopbackPropertyInfo = (~) ()-    type AttrBaseTypeConstraint InetAddressIsLoopbackPropertyInfo = InetAddressK-    type AttrGetType InetAddressIsLoopbackPropertyInfo = Bool-    type AttrLabel InetAddressIsLoopbackPropertyInfo = "InetAddress::is-loopback"-    attrGet _ = getInetAddressIsLoopback-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "is-mc-global"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable]--getInetAddressIsMcGlobal :: (MonadIO m, InetAddressK o) => o -> m Bool-getInetAddressIsMcGlobal obj = liftIO $ getObjectPropertyBool obj "is-mc-global"--data InetAddressIsMcGlobalPropertyInfo-instance AttrInfo InetAddressIsMcGlobalPropertyInfo where-    type AttrAllowedOps InetAddressIsMcGlobalPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint InetAddressIsMcGlobalPropertyInfo = (~) ()-    type AttrBaseTypeConstraint InetAddressIsMcGlobalPropertyInfo = InetAddressK-    type AttrGetType InetAddressIsMcGlobalPropertyInfo = Bool-    type AttrLabel InetAddressIsMcGlobalPropertyInfo = "InetAddress::is-mc-global"-    attrGet _ = getInetAddressIsMcGlobal-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "is-mc-link-local"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable]--getInetAddressIsMcLinkLocal :: (MonadIO m, InetAddressK o) => o -> m Bool-getInetAddressIsMcLinkLocal obj = liftIO $ getObjectPropertyBool obj "is-mc-link-local"--data InetAddressIsMcLinkLocalPropertyInfo-instance AttrInfo InetAddressIsMcLinkLocalPropertyInfo where-    type AttrAllowedOps InetAddressIsMcLinkLocalPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint InetAddressIsMcLinkLocalPropertyInfo = (~) ()-    type AttrBaseTypeConstraint InetAddressIsMcLinkLocalPropertyInfo = InetAddressK-    type AttrGetType InetAddressIsMcLinkLocalPropertyInfo = Bool-    type AttrLabel InetAddressIsMcLinkLocalPropertyInfo = "InetAddress::is-mc-link-local"-    attrGet _ = getInetAddressIsMcLinkLocal-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "is-mc-node-local"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable]--getInetAddressIsMcNodeLocal :: (MonadIO m, InetAddressK o) => o -> m Bool-getInetAddressIsMcNodeLocal obj = liftIO $ getObjectPropertyBool obj "is-mc-node-local"--data InetAddressIsMcNodeLocalPropertyInfo-instance AttrInfo InetAddressIsMcNodeLocalPropertyInfo where-    type AttrAllowedOps InetAddressIsMcNodeLocalPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint InetAddressIsMcNodeLocalPropertyInfo = (~) ()-    type AttrBaseTypeConstraint InetAddressIsMcNodeLocalPropertyInfo = InetAddressK-    type AttrGetType InetAddressIsMcNodeLocalPropertyInfo = Bool-    type AttrLabel InetAddressIsMcNodeLocalPropertyInfo = "InetAddress::is-mc-node-local"-    attrGet _ = getInetAddressIsMcNodeLocal-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "is-mc-org-local"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable]--getInetAddressIsMcOrgLocal :: (MonadIO m, InetAddressK o) => o -> m Bool-getInetAddressIsMcOrgLocal obj = liftIO $ getObjectPropertyBool obj "is-mc-org-local"--data InetAddressIsMcOrgLocalPropertyInfo-instance AttrInfo InetAddressIsMcOrgLocalPropertyInfo where-    type AttrAllowedOps InetAddressIsMcOrgLocalPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint InetAddressIsMcOrgLocalPropertyInfo = (~) ()-    type AttrBaseTypeConstraint InetAddressIsMcOrgLocalPropertyInfo = InetAddressK-    type AttrGetType InetAddressIsMcOrgLocalPropertyInfo = Bool-    type AttrLabel InetAddressIsMcOrgLocalPropertyInfo = "InetAddress::is-mc-org-local"-    attrGet _ = getInetAddressIsMcOrgLocal-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "is-mc-site-local"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable]--getInetAddressIsMcSiteLocal :: (MonadIO m, InetAddressK o) => o -> m Bool-getInetAddressIsMcSiteLocal obj = liftIO $ getObjectPropertyBool obj "is-mc-site-local"--data InetAddressIsMcSiteLocalPropertyInfo-instance AttrInfo InetAddressIsMcSiteLocalPropertyInfo where-    type AttrAllowedOps InetAddressIsMcSiteLocalPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint InetAddressIsMcSiteLocalPropertyInfo = (~) ()-    type AttrBaseTypeConstraint InetAddressIsMcSiteLocalPropertyInfo = InetAddressK-    type AttrGetType InetAddressIsMcSiteLocalPropertyInfo = Bool-    type AttrLabel InetAddressIsMcSiteLocalPropertyInfo = "InetAddress::is-mc-site-local"-    attrGet _ = getInetAddressIsMcSiteLocal-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "is-multicast"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable]--getInetAddressIsMulticast :: (MonadIO m, InetAddressK o) => o -> m Bool-getInetAddressIsMulticast obj = liftIO $ getObjectPropertyBool obj "is-multicast"--data InetAddressIsMulticastPropertyInfo-instance AttrInfo InetAddressIsMulticastPropertyInfo where-    type AttrAllowedOps InetAddressIsMulticastPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint InetAddressIsMulticastPropertyInfo = (~) ()-    type AttrBaseTypeConstraint InetAddressIsMulticastPropertyInfo = InetAddressK-    type AttrGetType InetAddressIsMulticastPropertyInfo = Bool-    type AttrLabel InetAddressIsMulticastPropertyInfo = "InetAddress::is-multicast"-    attrGet _ = getInetAddressIsMulticast-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "is-site-local"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable]--getInetAddressIsSiteLocal :: (MonadIO m, InetAddressK o) => o -> m Bool-getInetAddressIsSiteLocal obj = liftIO $ getObjectPropertyBool obj "is-site-local"--data InetAddressIsSiteLocalPropertyInfo-instance AttrInfo InetAddressIsSiteLocalPropertyInfo where-    type AttrAllowedOps InetAddressIsSiteLocalPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint InetAddressIsSiteLocalPropertyInfo = (~) ()-    type AttrBaseTypeConstraint InetAddressIsSiteLocalPropertyInfo = InetAddressK-    type AttrGetType InetAddressIsSiteLocalPropertyInfo = Bool-    type AttrLabel InetAddressIsSiteLocalPropertyInfo = "InetAddress::is-site-local"-    attrGet _ = getInetAddressIsSiteLocal-    attrSet _ = undefined-    attrConstruct _ = undefined--type instance AttributeList InetAddress = '[ '("bytes", InetAddressBytesPropertyInfo), '("family", InetAddressFamilyPropertyInfo), '("is-any", InetAddressIsAnyPropertyInfo), '("is-link-local", InetAddressIsLinkLocalPropertyInfo), '("is-loopback", InetAddressIsLoopbackPropertyInfo), '("is-mc-global", InetAddressIsMcGlobalPropertyInfo), '("is-mc-link-local", InetAddressIsMcLinkLocalPropertyInfo), '("is-mc-node-local", InetAddressIsMcNodeLocalPropertyInfo), '("is-mc-org-local", InetAddressIsMcOrgLocalPropertyInfo), '("is-mc-site-local", InetAddressIsMcSiteLocalPropertyInfo), '("is-multicast", InetAddressIsMulticastPropertyInfo), '("is-site-local", InetAddressIsSiteLocalPropertyInfo)]---- VVV Prop "address"-   -- Type: TInterface "Gio" "InetAddress"-   -- Flags: [PropertyReadable,PropertyWritable]--getInetAddressMaskAddress :: (MonadIO m, InetAddressMaskK o) => o -> m InetAddress-getInetAddressMaskAddress obj = liftIO $ getObjectPropertyObject obj "address" InetAddress--setInetAddressMaskAddress :: (MonadIO m, InetAddressMaskK o, InetAddressK a) => o -> a -> m ()-setInetAddressMaskAddress obj val = liftIO $ setObjectPropertyObject obj "address" val--constructInetAddressMaskAddress :: (InetAddressK a) => a -> IO ([Char], GValue)-constructInetAddressMaskAddress val = constructObjectPropertyObject "address" val--data InetAddressMaskAddressPropertyInfo-instance AttrInfo InetAddressMaskAddressPropertyInfo where-    type AttrAllowedOps InetAddressMaskAddressPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint InetAddressMaskAddressPropertyInfo = InetAddressK-    type AttrBaseTypeConstraint InetAddressMaskAddressPropertyInfo = InetAddressMaskK-    type AttrGetType InetAddressMaskAddressPropertyInfo = InetAddress-    type AttrLabel InetAddressMaskAddressPropertyInfo = "InetAddressMask::address"-    attrGet _ = getInetAddressMaskAddress-    attrSet _ = setInetAddressMaskAddress-    attrConstruct _ = constructInetAddressMaskAddress---- VVV Prop "family"-   -- Type: TInterface "Gio" "SocketFamily"-   -- Flags: [PropertyReadable]--getInetAddressMaskFamily :: (MonadIO m, InetAddressMaskK o) => o -> m SocketFamily-getInetAddressMaskFamily obj = liftIO $ getObjectPropertyEnum obj "family"--data InetAddressMaskFamilyPropertyInfo-instance AttrInfo InetAddressMaskFamilyPropertyInfo where-    type AttrAllowedOps InetAddressMaskFamilyPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint InetAddressMaskFamilyPropertyInfo = (~) ()-    type AttrBaseTypeConstraint InetAddressMaskFamilyPropertyInfo = InetAddressMaskK-    type AttrGetType InetAddressMaskFamilyPropertyInfo = SocketFamily-    type AttrLabel InetAddressMaskFamilyPropertyInfo = "InetAddressMask::family"-    attrGet _ = getInetAddressMaskFamily-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "length"-   -- Type: TBasicType TUInt32-   -- Flags: [PropertyReadable,PropertyWritable]--getInetAddressMaskLength :: (MonadIO m, InetAddressMaskK o) => o -> m Word32-getInetAddressMaskLength obj = liftIO $ getObjectPropertyCUInt obj "length"--setInetAddressMaskLength :: (MonadIO m, InetAddressMaskK o) => o -> Word32 -> m ()-setInetAddressMaskLength obj val = liftIO $ setObjectPropertyCUInt obj "length" val--constructInetAddressMaskLength :: Word32 -> IO ([Char], GValue)-constructInetAddressMaskLength val = constructObjectPropertyCUInt "length" val--data InetAddressMaskLengthPropertyInfo-instance AttrInfo InetAddressMaskLengthPropertyInfo where-    type AttrAllowedOps InetAddressMaskLengthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint InetAddressMaskLengthPropertyInfo = (~) Word32-    type AttrBaseTypeConstraint InetAddressMaskLengthPropertyInfo = InetAddressMaskK-    type AttrGetType InetAddressMaskLengthPropertyInfo = Word32-    type AttrLabel InetAddressMaskLengthPropertyInfo = "InetAddressMask::length"-    attrGet _ = getInetAddressMaskLength-    attrSet _ = setInetAddressMaskLength-    attrConstruct _ = constructInetAddressMaskLength--type instance AttributeList InetAddressMask = '[ '("address", InetAddressMaskAddressPropertyInfo), '("family", InetAddressMaskFamilyPropertyInfo), '("length", InetAddressMaskLengthPropertyInfo)]---- VVV Prop "address"-   -- Type: TInterface "Gio" "InetAddress"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getInetSocketAddressAddress :: (MonadIO m, InetSocketAddressK o) => o -> m InetAddress-getInetSocketAddressAddress obj = liftIO $ getObjectPropertyObject obj "address" InetAddress--constructInetSocketAddressAddress :: (InetAddressK a) => a -> IO ([Char], GValue)-constructInetSocketAddressAddress val = constructObjectPropertyObject "address" val--data InetSocketAddressAddressPropertyInfo-instance AttrInfo InetSocketAddressAddressPropertyInfo where-    type AttrAllowedOps InetSocketAddressAddressPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint InetSocketAddressAddressPropertyInfo = InetAddressK-    type AttrBaseTypeConstraint InetSocketAddressAddressPropertyInfo = InetSocketAddressK-    type AttrGetType InetSocketAddressAddressPropertyInfo = InetAddress-    type AttrLabel InetSocketAddressAddressPropertyInfo = "InetSocketAddress::address"-    attrGet _ = getInetSocketAddressAddress-    attrSet _ = undefined-    attrConstruct _ = constructInetSocketAddressAddress---- VVV Prop "flowinfo"-   -- Type: TBasicType TUInt32-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getInetSocketAddressFlowinfo :: (MonadIO m, InetSocketAddressK o) => o -> m Word32-getInetSocketAddressFlowinfo obj = liftIO $ getObjectPropertyCUInt obj "flowinfo"--constructInetSocketAddressFlowinfo :: Word32 -> IO ([Char], GValue)-constructInetSocketAddressFlowinfo val = constructObjectPropertyCUInt "flowinfo" val--data InetSocketAddressFlowinfoPropertyInfo-instance AttrInfo InetSocketAddressFlowinfoPropertyInfo where-    type AttrAllowedOps InetSocketAddressFlowinfoPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint InetSocketAddressFlowinfoPropertyInfo = (~) Word32-    type AttrBaseTypeConstraint InetSocketAddressFlowinfoPropertyInfo = InetSocketAddressK-    type AttrGetType InetSocketAddressFlowinfoPropertyInfo = Word32-    type AttrLabel InetSocketAddressFlowinfoPropertyInfo = "InetSocketAddress::flowinfo"-    attrGet _ = getInetSocketAddressFlowinfo-    attrSet _ = undefined-    attrConstruct _ = constructInetSocketAddressFlowinfo---- VVV Prop "port"-   -- Type: TBasicType TUInt32-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getInetSocketAddressPort :: (MonadIO m, InetSocketAddressK o) => o -> m Word32-getInetSocketAddressPort obj = liftIO $ getObjectPropertyCUInt obj "port"--constructInetSocketAddressPort :: Word32 -> IO ([Char], GValue)-constructInetSocketAddressPort val = constructObjectPropertyCUInt "port" val--data InetSocketAddressPortPropertyInfo-instance AttrInfo InetSocketAddressPortPropertyInfo where-    type AttrAllowedOps InetSocketAddressPortPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint InetSocketAddressPortPropertyInfo = (~) Word32-    type AttrBaseTypeConstraint InetSocketAddressPortPropertyInfo = InetSocketAddressK-    type AttrGetType InetSocketAddressPortPropertyInfo = Word32-    type AttrLabel InetSocketAddressPortPropertyInfo = "InetSocketAddress::port"-    attrGet _ = getInetSocketAddressPort-    attrSet _ = undefined-    attrConstruct _ = constructInetSocketAddressPort---- VVV Prop "scope-id"-   -- Type: TBasicType TUInt32-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getInetSocketAddressScopeId :: (MonadIO m, InetSocketAddressK o) => o -> m Word32-getInetSocketAddressScopeId obj = liftIO $ getObjectPropertyCUInt obj "scope-id"--constructInetSocketAddressScopeId :: Word32 -> IO ([Char], GValue)-constructInetSocketAddressScopeId val = constructObjectPropertyCUInt "scope-id" val--data InetSocketAddressScopeIdPropertyInfo-instance AttrInfo InetSocketAddressScopeIdPropertyInfo where-    type AttrAllowedOps InetSocketAddressScopeIdPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint InetSocketAddressScopeIdPropertyInfo = (~) Word32-    type AttrBaseTypeConstraint InetSocketAddressScopeIdPropertyInfo = InetSocketAddressK-    type AttrGetType InetSocketAddressScopeIdPropertyInfo = Word32-    type AttrLabel InetSocketAddressScopeIdPropertyInfo = "InetSocketAddress::scope-id"-    attrGet _ = getInetSocketAddressScopeId-    attrSet _ = undefined-    attrConstruct _ = constructInetSocketAddressScopeId--type instance AttributeList InetSocketAddress = '[ '("address", InetSocketAddressAddressPropertyInfo), '("family", SocketAddressFamilyPropertyInfo), '("flowinfo", InetSocketAddressFlowinfoPropertyInfo), '("port", InetSocketAddressPortPropertyInfo), '("scope-id", InetSocketAddressScopeIdPropertyInfo)]--type instance AttributeList Initable = '[ ]--type instance AttributeList InputStream = '[ ]--type instance AttributeList ListModel = '[ ]---- VVV Prop "item-type"-   -- Type: TBasicType TGType-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getListStoreItemType :: (MonadIO m, ListStoreK o) => o -> m GType-getListStoreItemType obj = liftIO $ getObjectPropertyGType obj "item-type"--constructListStoreItemType :: GType -> IO ([Char], GValue)-constructListStoreItemType val = constructObjectPropertyGType "item-type" val--data ListStoreItemTypePropertyInfo-instance AttrInfo ListStoreItemTypePropertyInfo where-    type AttrAllowedOps ListStoreItemTypePropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint ListStoreItemTypePropertyInfo = (~) GType-    type AttrBaseTypeConstraint ListStoreItemTypePropertyInfo = ListStoreK-    type AttrGetType ListStoreItemTypePropertyInfo = GType-    type AttrLabel ListStoreItemTypePropertyInfo = "ListStore::item-type"-    attrGet _ = getListStoreItemType-    attrSet _ = undefined-    attrConstruct _ = constructListStoreItemType--type instance AttributeList ListStore = '[ '("item-type", ListStoreItemTypePropertyInfo)]--type instance AttributeList LoadableIcon = '[ ]--type instance AttributeList MemoryInputStream = '[ ]---- VVV Prop "data"-   -- Type: TBasicType TVoid-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getMemoryOutputStreamData :: (MonadIO m, MemoryOutputStreamK o) => o -> m (Ptr ())-getMemoryOutputStreamData obj = liftIO $ getObjectPropertyPtr obj "data"--constructMemoryOutputStreamData :: (Ptr ()) -> IO ([Char], GValue)-constructMemoryOutputStreamData val = constructObjectPropertyPtr "data" val--data MemoryOutputStreamDataPropertyInfo-instance AttrInfo MemoryOutputStreamDataPropertyInfo where-    type AttrAllowedOps MemoryOutputStreamDataPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint MemoryOutputStreamDataPropertyInfo = (~) (Ptr ())-    type AttrBaseTypeConstraint MemoryOutputStreamDataPropertyInfo = MemoryOutputStreamK-    type AttrGetType MemoryOutputStreamDataPropertyInfo = (Ptr ())-    type AttrLabel MemoryOutputStreamDataPropertyInfo = "MemoryOutputStream::data"-    attrGet _ = getMemoryOutputStreamData-    attrSet _ = undefined-    attrConstruct _ = constructMemoryOutputStreamData---- VVV Prop "data-size"-   -- Type: TBasicType TUInt64-   -- Flags: [PropertyReadable]--getMemoryOutputStreamDataSize :: (MonadIO m, MemoryOutputStreamK o) => o -> m Word64-getMemoryOutputStreamDataSize obj = liftIO $ getObjectPropertyUInt64 obj "data-size"--data MemoryOutputStreamDataSizePropertyInfo-instance AttrInfo MemoryOutputStreamDataSizePropertyInfo where-    type AttrAllowedOps MemoryOutputStreamDataSizePropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint MemoryOutputStreamDataSizePropertyInfo = (~) ()-    type AttrBaseTypeConstraint MemoryOutputStreamDataSizePropertyInfo = MemoryOutputStreamK-    type AttrGetType MemoryOutputStreamDataSizePropertyInfo = Word64-    type AttrLabel MemoryOutputStreamDataSizePropertyInfo = "MemoryOutputStream::data-size"-    attrGet _ = getMemoryOutputStreamDataSize-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "size"-   -- Type: TBasicType TUInt64-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getMemoryOutputStreamSize :: (MonadIO m, MemoryOutputStreamK o) => o -> m Word64-getMemoryOutputStreamSize obj = liftIO $ getObjectPropertyUInt64 obj "size"--constructMemoryOutputStreamSize :: Word64 -> IO ([Char], GValue)-constructMemoryOutputStreamSize val = constructObjectPropertyUInt64 "size" val--data MemoryOutputStreamSizePropertyInfo-instance AttrInfo MemoryOutputStreamSizePropertyInfo where-    type AttrAllowedOps MemoryOutputStreamSizePropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint MemoryOutputStreamSizePropertyInfo = (~) Word64-    type AttrBaseTypeConstraint MemoryOutputStreamSizePropertyInfo = MemoryOutputStreamK-    type AttrGetType MemoryOutputStreamSizePropertyInfo = Word64-    type AttrLabel MemoryOutputStreamSizePropertyInfo = "MemoryOutputStream::size"-    attrGet _ = getMemoryOutputStreamSize-    attrSet _ = undefined-    attrConstruct _ = constructMemoryOutputStreamSize--type instance AttributeList MemoryOutputStream = '[ '("data", MemoryOutputStreamDataPropertyInfo), '("data-size", MemoryOutputStreamDataSizePropertyInfo), '("size", MemoryOutputStreamSizePropertyInfo)]--type instance AttributeList Menu = '[ ]--type instance AttributeList MenuAttributeIter = '[ ]--type instance AttributeList MenuItem = '[ ]--type instance AttributeList MenuLinkIter = '[ ]--type instance AttributeList MenuModel = '[ ]--type instance AttributeList Mount = '[ ]---- VVV Prop "anonymous"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable,PropertyWritable]--getMountOperationAnonymous :: (MonadIO m, MountOperationK o) => o -> m Bool-getMountOperationAnonymous obj = liftIO $ getObjectPropertyBool obj "anonymous"--setMountOperationAnonymous :: (MonadIO m, MountOperationK o) => o -> Bool -> m ()-setMountOperationAnonymous obj val = liftIO $ setObjectPropertyBool obj "anonymous" val--constructMountOperationAnonymous :: Bool -> IO ([Char], GValue)-constructMountOperationAnonymous val = constructObjectPropertyBool "anonymous" val--data MountOperationAnonymousPropertyInfo-instance AttrInfo MountOperationAnonymousPropertyInfo where-    type AttrAllowedOps MountOperationAnonymousPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint MountOperationAnonymousPropertyInfo = (~) Bool-    type AttrBaseTypeConstraint MountOperationAnonymousPropertyInfo = MountOperationK-    type AttrGetType MountOperationAnonymousPropertyInfo = Bool-    type AttrLabel MountOperationAnonymousPropertyInfo = "MountOperation::anonymous"-    attrGet _ = getMountOperationAnonymous-    attrSet _ = setMountOperationAnonymous-    attrConstruct _ = constructMountOperationAnonymous---- VVV Prop "choice"-   -- Type: TBasicType TInt32-   -- Flags: [PropertyReadable,PropertyWritable]--getMountOperationChoice :: (MonadIO m, MountOperationK o) => o -> m Int32-getMountOperationChoice obj = liftIO $ getObjectPropertyCInt obj "choice"--setMountOperationChoice :: (MonadIO m, MountOperationK o) => o -> Int32 -> m ()-setMountOperationChoice obj val = liftIO $ setObjectPropertyCInt obj "choice" val--constructMountOperationChoice :: Int32 -> IO ([Char], GValue)-constructMountOperationChoice val = constructObjectPropertyCInt "choice" val--data MountOperationChoicePropertyInfo-instance AttrInfo MountOperationChoicePropertyInfo where-    type AttrAllowedOps MountOperationChoicePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint MountOperationChoicePropertyInfo = (~) Int32-    type AttrBaseTypeConstraint MountOperationChoicePropertyInfo = MountOperationK-    type AttrGetType MountOperationChoicePropertyInfo = Int32-    type AttrLabel MountOperationChoicePropertyInfo = "MountOperation::choice"-    attrGet _ = getMountOperationChoice-    attrSet _ = setMountOperationChoice-    attrConstruct _ = constructMountOperationChoice---- VVV Prop "domain"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable]--getMountOperationDomain :: (MonadIO m, MountOperationK o) => o -> m T.Text-getMountOperationDomain obj = liftIO $ getObjectPropertyString obj "domain"--setMountOperationDomain :: (MonadIO m, MountOperationK o) => o -> T.Text -> m ()-setMountOperationDomain obj val = liftIO $ setObjectPropertyString obj "domain" val--constructMountOperationDomain :: T.Text -> IO ([Char], GValue)-constructMountOperationDomain val = constructObjectPropertyString "domain" val--data MountOperationDomainPropertyInfo-instance AttrInfo MountOperationDomainPropertyInfo where-    type AttrAllowedOps MountOperationDomainPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint MountOperationDomainPropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint MountOperationDomainPropertyInfo = MountOperationK-    type AttrGetType MountOperationDomainPropertyInfo = T.Text-    type AttrLabel MountOperationDomainPropertyInfo = "MountOperation::domain"-    attrGet _ = getMountOperationDomain-    attrSet _ = setMountOperationDomain-    attrConstruct _ = constructMountOperationDomain---- VVV Prop "password"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable]--getMountOperationPassword :: (MonadIO m, MountOperationK o) => o -> m T.Text-getMountOperationPassword obj = liftIO $ getObjectPropertyString obj "password"--setMountOperationPassword :: (MonadIO m, MountOperationK o) => o -> T.Text -> m ()-setMountOperationPassword obj val = liftIO $ setObjectPropertyString obj "password" val--constructMountOperationPassword :: T.Text -> IO ([Char], GValue)-constructMountOperationPassword val = constructObjectPropertyString "password" val--data MountOperationPasswordPropertyInfo-instance AttrInfo MountOperationPasswordPropertyInfo where-    type AttrAllowedOps MountOperationPasswordPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint MountOperationPasswordPropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint MountOperationPasswordPropertyInfo = MountOperationK-    type AttrGetType MountOperationPasswordPropertyInfo = T.Text-    type AttrLabel MountOperationPasswordPropertyInfo = "MountOperation::password"-    attrGet _ = getMountOperationPassword-    attrSet _ = setMountOperationPassword-    attrConstruct _ = constructMountOperationPassword---- VVV Prop "password-save"-   -- Type: TInterface "Gio" "PasswordSave"-   -- Flags: [PropertyReadable,PropertyWritable]--getMountOperationPasswordSave :: (MonadIO m, MountOperationK o) => o -> m PasswordSave-getMountOperationPasswordSave obj = liftIO $ getObjectPropertyEnum obj "password-save"--setMountOperationPasswordSave :: (MonadIO m, MountOperationK o) => o -> PasswordSave -> m ()-setMountOperationPasswordSave obj val = liftIO $ setObjectPropertyEnum obj "password-save" val--constructMountOperationPasswordSave :: PasswordSave -> IO ([Char], GValue)-constructMountOperationPasswordSave val = constructObjectPropertyEnum "password-save" val--data MountOperationPasswordSavePropertyInfo-instance AttrInfo MountOperationPasswordSavePropertyInfo where-    type AttrAllowedOps MountOperationPasswordSavePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint MountOperationPasswordSavePropertyInfo = (~) PasswordSave-    type AttrBaseTypeConstraint MountOperationPasswordSavePropertyInfo = MountOperationK-    type AttrGetType MountOperationPasswordSavePropertyInfo = PasswordSave-    type AttrLabel MountOperationPasswordSavePropertyInfo = "MountOperation::password-save"-    attrGet _ = getMountOperationPasswordSave-    attrSet _ = setMountOperationPasswordSave-    attrConstruct _ = constructMountOperationPasswordSave---- VVV Prop "username"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable]--getMountOperationUsername :: (MonadIO m, MountOperationK o) => o -> m T.Text-getMountOperationUsername obj = liftIO $ getObjectPropertyString obj "username"--setMountOperationUsername :: (MonadIO m, MountOperationK o) => o -> T.Text -> m ()-setMountOperationUsername obj val = liftIO $ setObjectPropertyString obj "username" val--constructMountOperationUsername :: T.Text -> IO ([Char], GValue)-constructMountOperationUsername val = constructObjectPropertyString "username" val--data MountOperationUsernamePropertyInfo-instance AttrInfo MountOperationUsernamePropertyInfo where-    type AttrAllowedOps MountOperationUsernamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint MountOperationUsernamePropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint MountOperationUsernamePropertyInfo = MountOperationK-    type AttrGetType MountOperationUsernamePropertyInfo = T.Text-    type AttrLabel MountOperationUsernamePropertyInfo = "MountOperation::username"-    attrGet _ = getMountOperationUsername-    attrSet _ = setMountOperationUsername-    attrConstruct _ = constructMountOperationUsername--type instance AttributeList MountOperation = '[ '("anonymous", MountOperationAnonymousPropertyInfo), '("choice", MountOperationChoicePropertyInfo), '("domain", MountOperationDomainPropertyInfo), '("password", MountOperationPasswordPropertyInfo), '("password-save", MountOperationPasswordSavePropertyInfo), '("username", MountOperationUsernamePropertyInfo)]--type instance AttributeList NativeVolumeMonitor = '[ ]---- VVV Prop "hostname"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getNetworkAddressHostname :: (MonadIO m, NetworkAddressK o) => o -> m T.Text-getNetworkAddressHostname obj = liftIO $ getObjectPropertyString obj "hostname"--constructNetworkAddressHostname :: T.Text -> IO ([Char], GValue)-constructNetworkAddressHostname val = constructObjectPropertyString "hostname" val--data NetworkAddressHostnamePropertyInfo-instance AttrInfo NetworkAddressHostnamePropertyInfo where-    type AttrAllowedOps NetworkAddressHostnamePropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint NetworkAddressHostnamePropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint NetworkAddressHostnamePropertyInfo = NetworkAddressK-    type AttrGetType NetworkAddressHostnamePropertyInfo = T.Text-    type AttrLabel NetworkAddressHostnamePropertyInfo = "NetworkAddress::hostname"-    attrGet _ = getNetworkAddressHostname-    attrSet _ = undefined-    attrConstruct _ = constructNetworkAddressHostname---- VVV Prop "port"-   -- Type: TBasicType TUInt32-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getNetworkAddressPort :: (MonadIO m, NetworkAddressK o) => o -> m Word32-getNetworkAddressPort obj = liftIO $ getObjectPropertyCUInt obj "port"--constructNetworkAddressPort :: Word32 -> IO ([Char], GValue)-constructNetworkAddressPort val = constructObjectPropertyCUInt "port" val--data NetworkAddressPortPropertyInfo-instance AttrInfo NetworkAddressPortPropertyInfo where-    type AttrAllowedOps NetworkAddressPortPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint NetworkAddressPortPropertyInfo = (~) Word32-    type AttrBaseTypeConstraint NetworkAddressPortPropertyInfo = NetworkAddressK-    type AttrGetType NetworkAddressPortPropertyInfo = Word32-    type AttrLabel NetworkAddressPortPropertyInfo = "NetworkAddress::port"-    attrGet _ = getNetworkAddressPort-    attrSet _ = undefined-    attrConstruct _ = constructNetworkAddressPort---- VVV Prop "scheme"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getNetworkAddressScheme :: (MonadIO m, NetworkAddressK o) => o -> m T.Text-getNetworkAddressScheme obj = liftIO $ getObjectPropertyString obj "scheme"--constructNetworkAddressScheme :: T.Text -> IO ([Char], GValue)-constructNetworkAddressScheme val = constructObjectPropertyString "scheme" val--data NetworkAddressSchemePropertyInfo-instance AttrInfo NetworkAddressSchemePropertyInfo where-    type AttrAllowedOps NetworkAddressSchemePropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint NetworkAddressSchemePropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint NetworkAddressSchemePropertyInfo = NetworkAddressK-    type AttrGetType NetworkAddressSchemePropertyInfo = T.Text-    type AttrLabel NetworkAddressSchemePropertyInfo = "NetworkAddress::scheme"-    attrGet _ = getNetworkAddressScheme-    attrSet _ = undefined-    attrConstruct _ = constructNetworkAddressScheme--type instance AttributeList NetworkAddress = '[ '("hostname", NetworkAddressHostnamePropertyInfo), '("port", NetworkAddressPortPropertyInfo), '("scheme", NetworkAddressSchemePropertyInfo)]---- VVV Prop "connectivity"-   -- Type: TInterface "Gio" "NetworkConnectivity"-   -- Flags: [PropertyReadable]--getNetworkMonitorConnectivity :: (MonadIO m, NetworkMonitorK o) => o -> m NetworkConnectivity-getNetworkMonitorConnectivity obj = liftIO $ getObjectPropertyEnum obj "connectivity"--data NetworkMonitorConnectivityPropertyInfo-instance AttrInfo NetworkMonitorConnectivityPropertyInfo where-    type AttrAllowedOps NetworkMonitorConnectivityPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint NetworkMonitorConnectivityPropertyInfo = (~) ()-    type AttrBaseTypeConstraint NetworkMonitorConnectivityPropertyInfo = NetworkMonitorK-    type AttrGetType NetworkMonitorConnectivityPropertyInfo = NetworkConnectivity-    type AttrLabel NetworkMonitorConnectivityPropertyInfo = "NetworkMonitor::connectivity"-    attrGet _ = getNetworkMonitorConnectivity-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "network-available"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable]--getNetworkMonitorNetworkAvailable :: (MonadIO m, NetworkMonitorK o) => o -> m Bool-getNetworkMonitorNetworkAvailable obj = liftIO $ getObjectPropertyBool obj "network-available"--data NetworkMonitorNetworkAvailablePropertyInfo-instance AttrInfo NetworkMonitorNetworkAvailablePropertyInfo where-    type AttrAllowedOps NetworkMonitorNetworkAvailablePropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint NetworkMonitorNetworkAvailablePropertyInfo = (~) ()-    type AttrBaseTypeConstraint NetworkMonitorNetworkAvailablePropertyInfo = NetworkMonitorK-    type AttrGetType NetworkMonitorNetworkAvailablePropertyInfo = Bool-    type AttrLabel NetworkMonitorNetworkAvailablePropertyInfo = "NetworkMonitor::network-available"-    attrGet _ = getNetworkMonitorNetworkAvailable-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "network-metered"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable]--getNetworkMonitorNetworkMetered :: (MonadIO m, NetworkMonitorK o) => o -> m Bool-getNetworkMonitorNetworkMetered obj = liftIO $ getObjectPropertyBool obj "network-metered"--data NetworkMonitorNetworkMeteredPropertyInfo-instance AttrInfo NetworkMonitorNetworkMeteredPropertyInfo where-    type AttrAllowedOps NetworkMonitorNetworkMeteredPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint NetworkMonitorNetworkMeteredPropertyInfo = (~) ()-    type AttrBaseTypeConstraint NetworkMonitorNetworkMeteredPropertyInfo = NetworkMonitorK-    type AttrGetType NetworkMonitorNetworkMeteredPropertyInfo = Bool-    type AttrLabel NetworkMonitorNetworkMeteredPropertyInfo = "NetworkMonitor::network-metered"-    attrGet _ = getNetworkMonitorNetworkMetered-    attrSet _ = undefined-    attrConstruct _ = undefined--type instance AttributeList NetworkMonitor = '[ '("connectivity", NetworkMonitorConnectivityPropertyInfo), '("network-available", NetworkMonitorNetworkAvailablePropertyInfo), '("network-metered", NetworkMonitorNetworkMeteredPropertyInfo)]---- VVV Prop "domain"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getNetworkServiceDomain :: (MonadIO m, NetworkServiceK o) => o -> m T.Text-getNetworkServiceDomain obj = liftIO $ getObjectPropertyString obj "domain"--constructNetworkServiceDomain :: T.Text -> IO ([Char], GValue)-constructNetworkServiceDomain val = constructObjectPropertyString "domain" val--data NetworkServiceDomainPropertyInfo-instance AttrInfo NetworkServiceDomainPropertyInfo where-    type AttrAllowedOps NetworkServiceDomainPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint NetworkServiceDomainPropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint NetworkServiceDomainPropertyInfo = NetworkServiceK-    type AttrGetType NetworkServiceDomainPropertyInfo = T.Text-    type AttrLabel NetworkServiceDomainPropertyInfo = "NetworkService::domain"-    attrGet _ = getNetworkServiceDomain-    attrSet _ = undefined-    attrConstruct _ = constructNetworkServiceDomain---- VVV Prop "protocol"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getNetworkServiceProtocol :: (MonadIO m, NetworkServiceK o) => o -> m T.Text-getNetworkServiceProtocol obj = liftIO $ getObjectPropertyString obj "protocol"--constructNetworkServiceProtocol :: T.Text -> IO ([Char], GValue)-constructNetworkServiceProtocol val = constructObjectPropertyString "protocol" val--data NetworkServiceProtocolPropertyInfo-instance AttrInfo NetworkServiceProtocolPropertyInfo where-    type AttrAllowedOps NetworkServiceProtocolPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint NetworkServiceProtocolPropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint NetworkServiceProtocolPropertyInfo = NetworkServiceK-    type AttrGetType NetworkServiceProtocolPropertyInfo = T.Text-    type AttrLabel NetworkServiceProtocolPropertyInfo = "NetworkService::protocol"-    attrGet _ = getNetworkServiceProtocol-    attrSet _ = undefined-    attrConstruct _ = constructNetworkServiceProtocol---- VVV Prop "scheme"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable]--getNetworkServiceScheme :: (MonadIO m, NetworkServiceK o) => o -> m T.Text-getNetworkServiceScheme obj = liftIO $ getObjectPropertyString obj "scheme"--setNetworkServiceScheme :: (MonadIO m, NetworkServiceK o) => o -> T.Text -> m ()-setNetworkServiceScheme obj val = liftIO $ setObjectPropertyString obj "scheme" val--constructNetworkServiceScheme :: T.Text -> IO ([Char], GValue)-constructNetworkServiceScheme val = constructObjectPropertyString "scheme" val--data NetworkServiceSchemePropertyInfo-instance AttrInfo NetworkServiceSchemePropertyInfo where-    type AttrAllowedOps NetworkServiceSchemePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint NetworkServiceSchemePropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint NetworkServiceSchemePropertyInfo = NetworkServiceK-    type AttrGetType NetworkServiceSchemePropertyInfo = T.Text-    type AttrLabel NetworkServiceSchemePropertyInfo = "NetworkService::scheme"-    attrGet _ = getNetworkServiceScheme-    attrSet _ = setNetworkServiceScheme-    attrConstruct _ = constructNetworkServiceScheme---- VVV Prop "service"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getNetworkServiceService :: (MonadIO m, NetworkServiceK o) => o -> m T.Text-getNetworkServiceService obj = liftIO $ getObjectPropertyString obj "service"--constructNetworkServiceService :: T.Text -> IO ([Char], GValue)-constructNetworkServiceService val = constructObjectPropertyString "service" val--data NetworkServiceServicePropertyInfo-instance AttrInfo NetworkServiceServicePropertyInfo where-    type AttrAllowedOps NetworkServiceServicePropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint NetworkServiceServicePropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint NetworkServiceServicePropertyInfo = NetworkServiceK-    type AttrGetType NetworkServiceServicePropertyInfo = T.Text-    type AttrLabel NetworkServiceServicePropertyInfo = "NetworkService::service"-    attrGet _ = getNetworkServiceService-    attrSet _ = undefined-    attrConstruct _ = constructNetworkServiceService--type instance AttributeList NetworkService = '[ '("domain", NetworkServiceDomainPropertyInfo), '("protocol", NetworkServiceProtocolPropertyInfo), '("scheme", NetworkServiceSchemePropertyInfo), '("service", NetworkServiceServicePropertyInfo)]--type instance AttributeList Notification = '[ ]--type instance AttributeList OutputStream = '[ ]---- VVV Prop "allowed"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable]--getPermissionAllowed :: (MonadIO m, PermissionK o) => o -> m Bool-getPermissionAllowed obj = liftIO $ getObjectPropertyBool obj "allowed"--data PermissionAllowedPropertyInfo-instance AttrInfo PermissionAllowedPropertyInfo where-    type AttrAllowedOps PermissionAllowedPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint PermissionAllowedPropertyInfo = (~) ()-    type AttrBaseTypeConstraint PermissionAllowedPropertyInfo = PermissionK-    type AttrGetType PermissionAllowedPropertyInfo = Bool-    type AttrLabel PermissionAllowedPropertyInfo = "Permission::allowed"-    attrGet _ = getPermissionAllowed-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "can-acquire"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable]--getPermissionCanAcquire :: (MonadIO m, PermissionK o) => o -> m Bool-getPermissionCanAcquire obj = liftIO $ getObjectPropertyBool obj "can-acquire"--data PermissionCanAcquirePropertyInfo-instance AttrInfo PermissionCanAcquirePropertyInfo where-    type AttrAllowedOps PermissionCanAcquirePropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint PermissionCanAcquirePropertyInfo = (~) ()-    type AttrBaseTypeConstraint PermissionCanAcquirePropertyInfo = PermissionK-    type AttrGetType PermissionCanAcquirePropertyInfo = Bool-    type AttrLabel PermissionCanAcquirePropertyInfo = "Permission::can-acquire"-    attrGet _ = getPermissionCanAcquire-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "can-release"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable]--getPermissionCanRelease :: (MonadIO m, PermissionK o) => o -> m Bool-getPermissionCanRelease obj = liftIO $ getObjectPropertyBool obj "can-release"--data PermissionCanReleasePropertyInfo-instance AttrInfo PermissionCanReleasePropertyInfo where-    type AttrAllowedOps PermissionCanReleasePropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint PermissionCanReleasePropertyInfo = (~) ()-    type AttrBaseTypeConstraint PermissionCanReleasePropertyInfo = PermissionK-    type AttrGetType PermissionCanReleasePropertyInfo = Bool-    type AttrLabel PermissionCanReleasePropertyInfo = "Permission::can-release"-    attrGet _ = getPermissionCanRelease-    attrSet _ = undefined-    attrConstruct _ = undefined--type instance AttributeList Permission = '[ '("allowed", PermissionAllowedPropertyInfo), '("can-acquire", PermissionCanAcquirePropertyInfo), '("can-release", PermissionCanReleasePropertyInfo)]--type instance AttributeList PollableInputStream = '[ ]--type instance AttributeList PollableOutputStream = '[ ]----- XXX Duplicated object with different types:-  --- Name {namespace = "Gio", name = "PropertyAction"} -> Property {propName = "name", propType = TBasicType TUTF8, propFlags = [PropertyReadable,PropertyWritable,PropertyConstructOnly], propTransfer = TransferNothing, propDeprecated = Nothing}-  --- Name {namespace = "Gio", name = "Action"} -> Property {propName = "name", propType = TBasicType TUTF8, propFlags = [PropertyReadable], propTransfer = TransferNothing, propDeprecated = Nothing}--- VVV Prop "enabled"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable]--getPropertyActionEnabled :: (MonadIO m, PropertyActionK o) => o -> m Bool-getPropertyActionEnabled obj = liftIO $ getObjectPropertyBool obj "enabled"--data PropertyActionEnabledPropertyInfo-instance AttrInfo PropertyActionEnabledPropertyInfo where-    type AttrAllowedOps PropertyActionEnabledPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint PropertyActionEnabledPropertyInfo = (~) ()-    type AttrBaseTypeConstraint PropertyActionEnabledPropertyInfo = PropertyActionK-    type AttrGetType PropertyActionEnabledPropertyInfo = Bool-    type AttrLabel PropertyActionEnabledPropertyInfo = "PropertyAction::enabled"-    attrGet _ = getPropertyActionEnabled-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "invert-boolean"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getPropertyActionInvertBoolean :: (MonadIO m, PropertyActionK o) => o -> m Bool-getPropertyActionInvertBoolean obj = liftIO $ getObjectPropertyBool obj "invert-boolean"--constructPropertyActionInvertBoolean :: Bool -> IO ([Char], GValue)-constructPropertyActionInvertBoolean val = constructObjectPropertyBool "invert-boolean" val--data PropertyActionInvertBooleanPropertyInfo-instance AttrInfo PropertyActionInvertBooleanPropertyInfo where-    type AttrAllowedOps PropertyActionInvertBooleanPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint PropertyActionInvertBooleanPropertyInfo = (~) Bool-    type AttrBaseTypeConstraint PropertyActionInvertBooleanPropertyInfo = PropertyActionK-    type AttrGetType PropertyActionInvertBooleanPropertyInfo = Bool-    type AttrLabel PropertyActionInvertBooleanPropertyInfo = "PropertyAction::invert-boolean"-    attrGet _ = getPropertyActionInvertBoolean-    attrSet _ = undefined-    attrConstruct _ = constructPropertyActionInvertBoolean---- VVV Prop "name"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getPropertyActionName :: (MonadIO m, PropertyActionK o) => o -> m T.Text-getPropertyActionName obj = liftIO $ getObjectPropertyString obj "name"--constructPropertyActionName :: T.Text -> IO ([Char], GValue)-constructPropertyActionName val = constructObjectPropertyString "name" val--data PropertyActionNamePropertyInfo-instance AttrInfo PropertyActionNamePropertyInfo where-    type AttrAllowedOps PropertyActionNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint PropertyActionNamePropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint PropertyActionNamePropertyInfo = PropertyActionK-    type AttrGetType PropertyActionNamePropertyInfo = T.Text-    type AttrLabel PropertyActionNamePropertyInfo = "PropertyAction::name"-    attrGet _ = getPropertyActionName-    attrSet _ = undefined-    attrConstruct _ = constructPropertyActionName---- VVV Prop "object"-   -- Type: TInterface "GObject" "Object"-   -- Flags: [PropertyWritable,PropertyConstructOnly]--constructPropertyActionObject :: (GObject.ObjectK a) => a -> IO ([Char], GValue)-constructPropertyActionObject val = constructObjectPropertyObject "object" val--data PropertyActionObjectPropertyInfo-instance AttrInfo PropertyActionObjectPropertyInfo where-    type AttrAllowedOps PropertyActionObjectPropertyInfo = '[ 'AttrConstruct]-    type AttrSetTypeConstraint PropertyActionObjectPropertyInfo = GObject.ObjectK-    type AttrBaseTypeConstraint PropertyActionObjectPropertyInfo = PropertyActionK-    type AttrGetType PropertyActionObjectPropertyInfo = ()-    type AttrLabel PropertyActionObjectPropertyInfo = "PropertyAction::object"-    attrGet _ = undefined-    attrSet _ = undefined-    attrConstruct _ = constructPropertyActionObject---- VVV Prop "parameter-type"-   -- Type: TInterface "GLib" "VariantType"-   -- Flags: [PropertyReadable]--getPropertyActionParameterType :: (MonadIO m, PropertyActionK o) => o -> m GLib.VariantType-getPropertyActionParameterType obj = liftIO $ getObjectPropertyBoxed obj "parameter-type" GLib.VariantType--data PropertyActionParameterTypePropertyInfo-instance AttrInfo PropertyActionParameterTypePropertyInfo where-    type AttrAllowedOps PropertyActionParameterTypePropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint PropertyActionParameterTypePropertyInfo = (~) ()-    type AttrBaseTypeConstraint PropertyActionParameterTypePropertyInfo = PropertyActionK-    type AttrGetType PropertyActionParameterTypePropertyInfo = GLib.VariantType-    type AttrLabel PropertyActionParameterTypePropertyInfo = "PropertyAction::parameter-type"-    attrGet _ = getPropertyActionParameterType-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "property-name"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyWritable,PropertyConstructOnly]--constructPropertyActionPropertyName :: T.Text -> IO ([Char], GValue)-constructPropertyActionPropertyName val = constructObjectPropertyString "property-name" val--data PropertyActionPropertyNamePropertyInfo-instance AttrInfo PropertyActionPropertyNamePropertyInfo where-    type AttrAllowedOps PropertyActionPropertyNamePropertyInfo = '[ 'AttrConstruct]-    type AttrSetTypeConstraint PropertyActionPropertyNamePropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint PropertyActionPropertyNamePropertyInfo = PropertyActionK-    type AttrGetType PropertyActionPropertyNamePropertyInfo = ()-    type AttrLabel PropertyActionPropertyNamePropertyInfo = "PropertyAction::property-name"-    attrGet _ = undefined-    attrSet _ = undefined-    attrConstruct _ = constructPropertyActionPropertyName---- VVV Prop "state"-   -- Type: TVariant-   -- Flags: [PropertyReadable]--getPropertyActionState :: (MonadIO m, PropertyActionK o) => o -> m GVariant-getPropertyActionState obj = liftIO $ getObjectPropertyVariant obj "state"--data PropertyActionStatePropertyInfo-instance AttrInfo PropertyActionStatePropertyInfo where-    type AttrAllowedOps PropertyActionStatePropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint PropertyActionStatePropertyInfo = (~) ()-    type AttrBaseTypeConstraint PropertyActionStatePropertyInfo = PropertyActionK-    type AttrGetType PropertyActionStatePropertyInfo = GVariant-    type AttrLabel PropertyActionStatePropertyInfo = "PropertyAction::state"-    attrGet _ = getPropertyActionState-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "state-type"-   -- Type: TInterface "GLib" "VariantType"-   -- Flags: [PropertyReadable]--getPropertyActionStateType :: (MonadIO m, PropertyActionK o) => o -> m GLib.VariantType-getPropertyActionStateType obj = liftIO $ getObjectPropertyBoxed obj "state-type" GLib.VariantType--data PropertyActionStateTypePropertyInfo-instance AttrInfo PropertyActionStateTypePropertyInfo where-    type AttrAllowedOps PropertyActionStateTypePropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint PropertyActionStateTypePropertyInfo = (~) ()-    type AttrBaseTypeConstraint PropertyActionStateTypePropertyInfo = PropertyActionK-    type AttrGetType PropertyActionStateTypePropertyInfo = GLib.VariantType-    type AttrLabel PropertyActionStateTypePropertyInfo = "PropertyAction::state-type"-    attrGet _ = getPropertyActionStateType-    attrSet _ = undefined-    attrConstruct _ = undefined--type instance AttributeList PropertyAction = '[ '("enabled", PropertyActionEnabledPropertyInfo), '("invert-boolean", PropertyActionInvertBooleanPropertyInfo), '("object", PropertyActionObjectPropertyInfo), '("parameter-type", PropertyActionParameterTypePropertyInfo), '("property-name", PropertyActionPropertyNamePropertyInfo), '("state", PropertyActionStatePropertyInfo), '("state-type", PropertyActionStateTypePropertyInfo)]--type instance AttributeList Proxy = '[ ]---- VVV Prop "destination-hostname"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getProxyAddressDestinationHostname :: (MonadIO m, ProxyAddressK o) => o -> m T.Text-getProxyAddressDestinationHostname obj = liftIO $ getObjectPropertyString obj "destination-hostname"--constructProxyAddressDestinationHostname :: T.Text -> IO ([Char], GValue)-constructProxyAddressDestinationHostname val = constructObjectPropertyString "destination-hostname" val--data ProxyAddressDestinationHostnamePropertyInfo-instance AttrInfo ProxyAddressDestinationHostnamePropertyInfo where-    type AttrAllowedOps ProxyAddressDestinationHostnamePropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint ProxyAddressDestinationHostnamePropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint ProxyAddressDestinationHostnamePropertyInfo = ProxyAddressK-    type AttrGetType ProxyAddressDestinationHostnamePropertyInfo = T.Text-    type AttrLabel ProxyAddressDestinationHostnamePropertyInfo = "ProxyAddress::destination-hostname"-    attrGet _ = getProxyAddressDestinationHostname-    attrSet _ = undefined-    attrConstruct _ = constructProxyAddressDestinationHostname---- VVV Prop "destination-port"-   -- Type: TBasicType TUInt32-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getProxyAddressDestinationPort :: (MonadIO m, ProxyAddressK o) => o -> m Word32-getProxyAddressDestinationPort obj = liftIO $ getObjectPropertyCUInt obj "destination-port"--constructProxyAddressDestinationPort :: Word32 -> IO ([Char], GValue)-constructProxyAddressDestinationPort val = constructObjectPropertyCUInt "destination-port" val--data ProxyAddressDestinationPortPropertyInfo-instance AttrInfo ProxyAddressDestinationPortPropertyInfo where-    type AttrAllowedOps ProxyAddressDestinationPortPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint ProxyAddressDestinationPortPropertyInfo = (~) Word32-    type AttrBaseTypeConstraint ProxyAddressDestinationPortPropertyInfo = ProxyAddressK-    type AttrGetType ProxyAddressDestinationPortPropertyInfo = Word32-    type AttrLabel ProxyAddressDestinationPortPropertyInfo = "ProxyAddress::destination-port"-    attrGet _ = getProxyAddressDestinationPort-    attrSet _ = undefined-    attrConstruct _ = constructProxyAddressDestinationPort---- VVV Prop "destination-protocol"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getProxyAddressDestinationProtocol :: (MonadIO m, ProxyAddressK o) => o -> m T.Text-getProxyAddressDestinationProtocol obj = liftIO $ getObjectPropertyString obj "destination-protocol"--constructProxyAddressDestinationProtocol :: T.Text -> IO ([Char], GValue)-constructProxyAddressDestinationProtocol val = constructObjectPropertyString "destination-protocol" val--data ProxyAddressDestinationProtocolPropertyInfo-instance AttrInfo ProxyAddressDestinationProtocolPropertyInfo where-    type AttrAllowedOps ProxyAddressDestinationProtocolPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint ProxyAddressDestinationProtocolPropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint ProxyAddressDestinationProtocolPropertyInfo = ProxyAddressK-    type AttrGetType ProxyAddressDestinationProtocolPropertyInfo = T.Text-    type AttrLabel ProxyAddressDestinationProtocolPropertyInfo = "ProxyAddress::destination-protocol"-    attrGet _ = getProxyAddressDestinationProtocol-    attrSet _ = undefined-    attrConstruct _ = constructProxyAddressDestinationProtocol---- VVV Prop "password"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getProxyAddressPassword :: (MonadIO m, ProxyAddressK o) => o -> m T.Text-getProxyAddressPassword obj = liftIO $ getObjectPropertyString obj "password"--constructProxyAddressPassword :: T.Text -> IO ([Char], GValue)-constructProxyAddressPassword val = constructObjectPropertyString "password" val--data ProxyAddressPasswordPropertyInfo-instance AttrInfo ProxyAddressPasswordPropertyInfo where-    type AttrAllowedOps ProxyAddressPasswordPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint ProxyAddressPasswordPropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint ProxyAddressPasswordPropertyInfo = ProxyAddressK-    type AttrGetType ProxyAddressPasswordPropertyInfo = T.Text-    type AttrLabel ProxyAddressPasswordPropertyInfo = "ProxyAddress::password"-    attrGet _ = getProxyAddressPassword-    attrSet _ = undefined-    attrConstruct _ = constructProxyAddressPassword---- VVV Prop "protocol"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getProxyAddressProtocol :: (MonadIO m, ProxyAddressK o) => o -> m T.Text-getProxyAddressProtocol obj = liftIO $ getObjectPropertyString obj "protocol"--constructProxyAddressProtocol :: T.Text -> IO ([Char], GValue)-constructProxyAddressProtocol val = constructObjectPropertyString "protocol" val--data ProxyAddressProtocolPropertyInfo-instance AttrInfo ProxyAddressProtocolPropertyInfo where-    type AttrAllowedOps ProxyAddressProtocolPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint ProxyAddressProtocolPropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint ProxyAddressProtocolPropertyInfo = ProxyAddressK-    type AttrGetType ProxyAddressProtocolPropertyInfo = T.Text-    type AttrLabel ProxyAddressProtocolPropertyInfo = "ProxyAddress::protocol"-    attrGet _ = getProxyAddressProtocol-    attrSet _ = undefined-    attrConstruct _ = constructProxyAddressProtocol---- VVV Prop "uri"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getProxyAddressUri :: (MonadIO m, ProxyAddressK o) => o -> m T.Text-getProxyAddressUri obj = liftIO $ getObjectPropertyString obj "uri"--constructProxyAddressUri :: T.Text -> IO ([Char], GValue)-constructProxyAddressUri val = constructObjectPropertyString "uri" val--data ProxyAddressUriPropertyInfo-instance AttrInfo ProxyAddressUriPropertyInfo where-    type AttrAllowedOps ProxyAddressUriPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint ProxyAddressUriPropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint ProxyAddressUriPropertyInfo = ProxyAddressK-    type AttrGetType ProxyAddressUriPropertyInfo = T.Text-    type AttrLabel ProxyAddressUriPropertyInfo = "ProxyAddress::uri"-    attrGet _ = getProxyAddressUri-    attrSet _ = undefined-    attrConstruct _ = constructProxyAddressUri---- VVV Prop "username"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getProxyAddressUsername :: (MonadIO m, ProxyAddressK o) => o -> m T.Text-getProxyAddressUsername obj = liftIO $ getObjectPropertyString obj "username"--constructProxyAddressUsername :: T.Text -> IO ([Char], GValue)-constructProxyAddressUsername val = constructObjectPropertyString "username" val--data ProxyAddressUsernamePropertyInfo-instance AttrInfo ProxyAddressUsernamePropertyInfo where-    type AttrAllowedOps ProxyAddressUsernamePropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint ProxyAddressUsernamePropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint ProxyAddressUsernamePropertyInfo = ProxyAddressK-    type AttrGetType ProxyAddressUsernamePropertyInfo = T.Text-    type AttrLabel ProxyAddressUsernamePropertyInfo = "ProxyAddress::username"-    attrGet _ = getProxyAddressUsername-    attrSet _ = undefined-    attrConstruct _ = constructProxyAddressUsername--type instance AttributeList ProxyAddress = '[ '("address", InetSocketAddressAddressPropertyInfo), '("destination-hostname", ProxyAddressDestinationHostnamePropertyInfo), '("destination-port", ProxyAddressDestinationPortPropertyInfo), '("destination-protocol", ProxyAddressDestinationProtocolPropertyInfo), '("family", SocketAddressFamilyPropertyInfo), '("flowinfo", InetSocketAddressFlowinfoPropertyInfo), '("password", ProxyAddressPasswordPropertyInfo), '("port", InetSocketAddressPortPropertyInfo), '("protocol", ProxyAddressProtocolPropertyInfo), '("scope-id", InetSocketAddressScopeIdPropertyInfo), '("uri", ProxyAddressUriPropertyInfo), '("username", ProxyAddressUsernamePropertyInfo)]---- VVV Prop "connectable"-   -- Type: TInterface "Gio" "SocketConnectable"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getProxyAddressEnumeratorConnectable :: (MonadIO m, ProxyAddressEnumeratorK o) => o -> m SocketConnectable-getProxyAddressEnumeratorConnectable obj = liftIO $ getObjectPropertyObject obj "connectable" SocketConnectable--constructProxyAddressEnumeratorConnectable :: (SocketConnectableK a) => a -> IO ([Char], GValue)-constructProxyAddressEnumeratorConnectable val = constructObjectPropertyObject "connectable" val--data ProxyAddressEnumeratorConnectablePropertyInfo-instance AttrInfo ProxyAddressEnumeratorConnectablePropertyInfo where-    type AttrAllowedOps ProxyAddressEnumeratorConnectablePropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint ProxyAddressEnumeratorConnectablePropertyInfo = SocketConnectableK-    type AttrBaseTypeConstraint ProxyAddressEnumeratorConnectablePropertyInfo = ProxyAddressEnumeratorK-    type AttrGetType ProxyAddressEnumeratorConnectablePropertyInfo = SocketConnectable-    type AttrLabel ProxyAddressEnumeratorConnectablePropertyInfo = "ProxyAddressEnumerator::connectable"-    attrGet _ = getProxyAddressEnumeratorConnectable-    attrSet _ = undefined-    attrConstruct _ = constructProxyAddressEnumeratorConnectable---- VVV Prop "default-port"-   -- Type: TBasicType TUInt32-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getProxyAddressEnumeratorDefaultPort :: (MonadIO m, ProxyAddressEnumeratorK o) => o -> m Word32-getProxyAddressEnumeratorDefaultPort obj = liftIO $ getObjectPropertyCUInt obj "default-port"--constructProxyAddressEnumeratorDefaultPort :: Word32 -> IO ([Char], GValue)-constructProxyAddressEnumeratorDefaultPort val = constructObjectPropertyCUInt "default-port" val--data ProxyAddressEnumeratorDefaultPortPropertyInfo-instance AttrInfo ProxyAddressEnumeratorDefaultPortPropertyInfo where-    type AttrAllowedOps ProxyAddressEnumeratorDefaultPortPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint ProxyAddressEnumeratorDefaultPortPropertyInfo = (~) Word32-    type AttrBaseTypeConstraint ProxyAddressEnumeratorDefaultPortPropertyInfo = ProxyAddressEnumeratorK-    type AttrGetType ProxyAddressEnumeratorDefaultPortPropertyInfo = Word32-    type AttrLabel ProxyAddressEnumeratorDefaultPortPropertyInfo = "ProxyAddressEnumerator::default-port"-    attrGet _ = getProxyAddressEnumeratorDefaultPort-    attrSet _ = undefined-    attrConstruct _ = constructProxyAddressEnumeratorDefaultPort---- VVV Prop "proxy-resolver"-   -- Type: TInterface "Gio" "ProxyResolver"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]--getProxyAddressEnumeratorProxyResolver :: (MonadIO m, ProxyAddressEnumeratorK o) => o -> m ProxyResolver-getProxyAddressEnumeratorProxyResolver obj = liftIO $ getObjectPropertyObject obj "proxy-resolver" ProxyResolver--setProxyAddressEnumeratorProxyResolver :: (MonadIO m, ProxyAddressEnumeratorK o, ProxyResolverK a) => o -> a -> m ()-setProxyAddressEnumeratorProxyResolver obj val = liftIO $ setObjectPropertyObject obj "proxy-resolver" val--constructProxyAddressEnumeratorProxyResolver :: (ProxyResolverK a) => a -> IO ([Char], GValue)-constructProxyAddressEnumeratorProxyResolver val = constructObjectPropertyObject "proxy-resolver" val--data ProxyAddressEnumeratorProxyResolverPropertyInfo-instance AttrInfo ProxyAddressEnumeratorProxyResolverPropertyInfo where-    type AttrAllowedOps ProxyAddressEnumeratorProxyResolverPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint ProxyAddressEnumeratorProxyResolverPropertyInfo = ProxyResolverK-    type AttrBaseTypeConstraint ProxyAddressEnumeratorProxyResolverPropertyInfo = ProxyAddressEnumeratorK-    type AttrGetType ProxyAddressEnumeratorProxyResolverPropertyInfo = ProxyResolver-    type AttrLabel ProxyAddressEnumeratorProxyResolverPropertyInfo = "ProxyAddressEnumerator::proxy-resolver"-    attrGet _ = getProxyAddressEnumeratorProxyResolver-    attrSet _ = setProxyAddressEnumeratorProxyResolver-    attrConstruct _ = constructProxyAddressEnumeratorProxyResolver---- VVV Prop "uri"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getProxyAddressEnumeratorUri :: (MonadIO m, ProxyAddressEnumeratorK o) => o -> m T.Text-getProxyAddressEnumeratorUri obj = liftIO $ getObjectPropertyString obj "uri"--constructProxyAddressEnumeratorUri :: T.Text -> IO ([Char], GValue)-constructProxyAddressEnumeratorUri val = constructObjectPropertyString "uri" val--data ProxyAddressEnumeratorUriPropertyInfo-instance AttrInfo ProxyAddressEnumeratorUriPropertyInfo where-    type AttrAllowedOps ProxyAddressEnumeratorUriPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint ProxyAddressEnumeratorUriPropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint ProxyAddressEnumeratorUriPropertyInfo = ProxyAddressEnumeratorK-    type AttrGetType ProxyAddressEnumeratorUriPropertyInfo = T.Text-    type AttrLabel ProxyAddressEnumeratorUriPropertyInfo = "ProxyAddressEnumerator::uri"-    attrGet _ = getProxyAddressEnumeratorUri-    attrSet _ = undefined-    attrConstruct _ = constructProxyAddressEnumeratorUri--type instance AttributeList ProxyAddressEnumerator = '[ '("connectable", ProxyAddressEnumeratorConnectablePropertyInfo), '("default-port", ProxyAddressEnumeratorDefaultPortPropertyInfo), '("proxy-resolver", ProxyAddressEnumeratorProxyResolverPropertyInfo), '("uri", ProxyAddressEnumeratorUriPropertyInfo)]--type instance AttributeList ProxyResolver = '[ ]--type instance AttributeList RemoteActionGroup = '[ ]--type instance AttributeList Resolver = '[ ]--type instance AttributeList Seekable = '[ ]---- VVV Prop "delay-apply"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable]--getSettingsDelayApply :: (MonadIO m, SettingsK o) => o -> m Bool-getSettingsDelayApply obj = liftIO $ getObjectPropertyBool obj "delay-apply"--data SettingsDelayApplyPropertyInfo-instance AttrInfo SettingsDelayApplyPropertyInfo where-    type AttrAllowedOps SettingsDelayApplyPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint SettingsDelayApplyPropertyInfo = (~) ()-    type AttrBaseTypeConstraint SettingsDelayApplyPropertyInfo = SettingsK-    type AttrGetType SettingsDelayApplyPropertyInfo = Bool-    type AttrLabel SettingsDelayApplyPropertyInfo = "Settings::delay-apply"-    attrGet _ = getSettingsDelayApply-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "has-unapplied"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable]--getSettingsHasUnapplied :: (MonadIO m, SettingsK o) => o -> m Bool-getSettingsHasUnapplied obj = liftIO $ getObjectPropertyBool obj "has-unapplied"--data SettingsHasUnappliedPropertyInfo-instance AttrInfo SettingsHasUnappliedPropertyInfo where-    type AttrAllowedOps SettingsHasUnappliedPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint SettingsHasUnappliedPropertyInfo = (~) ()-    type AttrBaseTypeConstraint SettingsHasUnappliedPropertyInfo = SettingsK-    type AttrGetType SettingsHasUnappliedPropertyInfo = Bool-    type AttrLabel SettingsHasUnappliedPropertyInfo = "Settings::has-unapplied"-    attrGet _ = getSettingsHasUnapplied-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "path"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getSettingsPath :: (MonadIO m, SettingsK o) => o -> m T.Text-getSettingsPath obj = liftIO $ getObjectPropertyString obj "path"--constructSettingsPath :: T.Text -> IO ([Char], GValue)-constructSettingsPath val = constructObjectPropertyString "path" val--data SettingsPathPropertyInfo-instance AttrInfo SettingsPathPropertyInfo where-    type AttrAllowedOps SettingsPathPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SettingsPathPropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint SettingsPathPropertyInfo = SettingsK-    type AttrGetType SettingsPathPropertyInfo = T.Text-    type AttrLabel SettingsPathPropertyInfo = "Settings::path"-    attrGet _ = getSettingsPath-    attrSet _ = undefined-    attrConstruct _ = constructSettingsPath---- VVV Prop "schema"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getSettingsSchema :: (MonadIO m, SettingsK o) => o -> m T.Text-getSettingsSchema obj = liftIO $ getObjectPropertyString obj "schema"--constructSettingsSchema :: T.Text -> IO ([Char], GValue)-constructSettingsSchema val = constructObjectPropertyString "schema" val--data SettingsSchemaPropertyInfo-instance AttrInfo SettingsSchemaPropertyInfo where-    type AttrAllowedOps SettingsSchemaPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SettingsSchemaPropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint SettingsSchemaPropertyInfo = SettingsK-    type AttrGetType SettingsSchemaPropertyInfo = T.Text-    type AttrLabel SettingsSchemaPropertyInfo = "Settings::schema"-    attrGet _ = getSettingsSchema-    attrSet _ = undefined-    attrConstruct _ = constructSettingsSchema---- VVV Prop "schema-id"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getSettingsSchemaId :: (MonadIO m, SettingsK o) => o -> m T.Text-getSettingsSchemaId obj = liftIO $ getObjectPropertyString obj "schema-id"--constructSettingsSchemaId :: T.Text -> IO ([Char], GValue)-constructSettingsSchemaId val = constructObjectPropertyString "schema-id" val--data SettingsSchemaIdPropertyInfo-instance AttrInfo SettingsSchemaIdPropertyInfo where-    type AttrAllowedOps SettingsSchemaIdPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SettingsSchemaIdPropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint SettingsSchemaIdPropertyInfo = SettingsK-    type AttrGetType SettingsSchemaIdPropertyInfo = T.Text-    type AttrLabel SettingsSchemaIdPropertyInfo = "Settings::schema-id"-    attrGet _ = getSettingsSchemaId-    attrSet _ = undefined-    attrConstruct _ = constructSettingsSchemaId---- VVV Prop "settings-schema"-   -- Type: TInterface "Gio" "SettingsSchema"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getSettingsSettingsSchema :: (MonadIO m, SettingsK o) => o -> m SettingsSchema-getSettingsSettingsSchema obj = liftIO $ getObjectPropertyBoxed obj "settings-schema" SettingsSchema--constructSettingsSettingsSchema :: SettingsSchema -> IO ([Char], GValue)-constructSettingsSettingsSchema val = constructObjectPropertyBoxed "settings-schema" val--data SettingsSettingsSchemaPropertyInfo-instance AttrInfo SettingsSettingsSchemaPropertyInfo where-    type AttrAllowedOps SettingsSettingsSchemaPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SettingsSettingsSchemaPropertyInfo = (~) SettingsSchema-    type AttrBaseTypeConstraint SettingsSettingsSchemaPropertyInfo = SettingsK-    type AttrGetType SettingsSettingsSchemaPropertyInfo = SettingsSchema-    type AttrLabel SettingsSettingsSchemaPropertyInfo = "Settings::settings-schema"-    attrGet _ = getSettingsSettingsSchema-    attrSet _ = undefined-    attrConstruct _ = constructSettingsSettingsSchema--type instance AttributeList Settings = '[ '("delay-apply", SettingsDelayApplyPropertyInfo), '("has-unapplied", SettingsHasUnappliedPropertyInfo), '("path", SettingsPathPropertyInfo), '("schema", SettingsSchemaPropertyInfo), '("schema-id", SettingsSchemaIdPropertyInfo), '("settings-schema", SettingsSettingsSchemaPropertyInfo)]----- XXX Duplicated object with different types:-  --- Name {namespace = "Gio", name = "SimpleAction"} -> Property {propName = "enabled", propType = TBasicType TBoolean, propFlags = [PropertyReadable,PropertyWritable], propTransfer = TransferNothing, propDeprecated = Nothing}-  --- Name {namespace = "Gio", name = "Action"} -> Property {propName = "enabled", propType = TBasicType TBoolean, propFlags = [PropertyReadable], propTransfer = TransferNothing, propDeprecated = Nothing}---- XXX Duplicated object with different types:-  --- Name {namespace = "Gio", name = "SimpleAction"} -> Property {propName = "name", propType = TBasicType TUTF8, propFlags = [PropertyReadable,PropertyWritable,PropertyConstructOnly], propTransfer = TransferNothing, propDeprecated = Nothing}-  --- Name {namespace = "Gio", name = "Action"} -> Property {propName = "name", propType = TBasicType TUTF8, propFlags = [PropertyReadable], propTransfer = TransferNothing, propDeprecated = Nothing}---- XXX Duplicated object with different types:-  --- Name {namespace = "Gio", name = "SimpleAction"} -> Property {propName = "parameter-type", propType = TInterface "GLib" "VariantType", propFlags = [PropertyReadable,PropertyWritable,PropertyConstructOnly], propTransfer = TransferNothing, propDeprecated = Nothing}-  --- Name {namespace = "Gio", name = "Action"} -> Property {propName = "parameter-type", propType = TInterface "GLib" "VariantType", propFlags = [PropertyReadable], propTransfer = TransferNothing, propDeprecated = Nothing}---- XXX Duplicated object with different types:-  --- Name {namespace = "Gio", name = "SimpleAction"} -> Property {propName = "state", propType = TVariant, propFlags = [PropertyReadable,PropertyWritable,PropertyConstruct], propTransfer = TransferNothing, propDeprecated = Nothing}-  --- Name {namespace = "Gio", name = "Action"} -> Property {propName = "state", propType = TVariant, propFlags = [PropertyReadable], propTransfer = TransferNothing, propDeprecated = Nothing}--- VVV Prop "enabled"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable,PropertyWritable]--getSimpleActionEnabled :: (MonadIO m, SimpleActionK o) => o -> m Bool-getSimpleActionEnabled obj = liftIO $ getObjectPropertyBool obj "enabled"--setSimpleActionEnabled :: (MonadIO m, SimpleActionK o) => o -> Bool -> m ()-setSimpleActionEnabled obj val = liftIO $ setObjectPropertyBool obj "enabled" val--constructSimpleActionEnabled :: Bool -> IO ([Char], GValue)-constructSimpleActionEnabled val = constructObjectPropertyBool "enabled" val--data SimpleActionEnabledPropertyInfo-instance AttrInfo SimpleActionEnabledPropertyInfo where-    type AttrAllowedOps SimpleActionEnabledPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SimpleActionEnabledPropertyInfo = (~) Bool-    type AttrBaseTypeConstraint SimpleActionEnabledPropertyInfo = SimpleActionK-    type AttrGetType SimpleActionEnabledPropertyInfo = Bool-    type AttrLabel SimpleActionEnabledPropertyInfo = "SimpleAction::enabled"-    attrGet _ = getSimpleActionEnabled-    attrSet _ = setSimpleActionEnabled-    attrConstruct _ = constructSimpleActionEnabled---- VVV Prop "name"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getSimpleActionName :: (MonadIO m, SimpleActionK o) => o -> m T.Text-getSimpleActionName obj = liftIO $ getObjectPropertyString obj "name"--constructSimpleActionName :: T.Text -> IO ([Char], GValue)-constructSimpleActionName val = constructObjectPropertyString "name" val--data SimpleActionNamePropertyInfo-instance AttrInfo SimpleActionNamePropertyInfo where-    type AttrAllowedOps SimpleActionNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SimpleActionNamePropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint SimpleActionNamePropertyInfo = SimpleActionK-    type AttrGetType SimpleActionNamePropertyInfo = T.Text-    type AttrLabel SimpleActionNamePropertyInfo = "SimpleAction::name"-    attrGet _ = getSimpleActionName-    attrSet _ = undefined-    attrConstruct _ = constructSimpleActionName---- VVV Prop "parameter-type"-   -- Type: TInterface "GLib" "VariantType"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getSimpleActionParameterType :: (MonadIO m, SimpleActionK o) => o -> m GLib.VariantType-getSimpleActionParameterType obj = liftIO $ getObjectPropertyBoxed obj "parameter-type" GLib.VariantType--constructSimpleActionParameterType :: GLib.VariantType -> IO ([Char], GValue)-constructSimpleActionParameterType val = constructObjectPropertyBoxed "parameter-type" val--data SimpleActionParameterTypePropertyInfo-instance AttrInfo SimpleActionParameterTypePropertyInfo where-    type AttrAllowedOps SimpleActionParameterTypePropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SimpleActionParameterTypePropertyInfo = (~) GLib.VariantType-    type AttrBaseTypeConstraint SimpleActionParameterTypePropertyInfo = SimpleActionK-    type AttrGetType SimpleActionParameterTypePropertyInfo = GLib.VariantType-    type AttrLabel SimpleActionParameterTypePropertyInfo = "SimpleAction::parameter-type"-    attrGet _ = getSimpleActionParameterType-    attrSet _ = undefined-    attrConstruct _ = constructSimpleActionParameterType---- VVV Prop "state"-   -- Type: TVariant-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]--getSimpleActionState :: (MonadIO m, SimpleActionK o) => o -> m GVariant-getSimpleActionState obj = liftIO $ getObjectPropertyVariant obj "state"--setSimpleActionState :: (MonadIO m, SimpleActionK o) => o -> GVariant -> m ()-setSimpleActionState obj val = liftIO $ setObjectPropertyVariant obj "state" val--constructSimpleActionState :: GVariant -> IO ([Char], GValue)-constructSimpleActionState val = constructObjectPropertyVariant "state" val--data SimpleActionStatePropertyInfo-instance AttrInfo SimpleActionStatePropertyInfo where-    type AttrAllowedOps SimpleActionStatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SimpleActionStatePropertyInfo = (~) GVariant-    type AttrBaseTypeConstraint SimpleActionStatePropertyInfo = SimpleActionK-    type AttrGetType SimpleActionStatePropertyInfo = GVariant-    type AttrLabel SimpleActionStatePropertyInfo = "SimpleAction::state"-    attrGet _ = getSimpleActionState-    attrSet _ = setSimpleActionState-    attrConstruct _ = constructSimpleActionState---- VVV Prop "state-type"-   -- Type: TInterface "GLib" "VariantType"-   -- Flags: [PropertyReadable]--getSimpleActionStateType :: (MonadIO m, SimpleActionK o) => o -> m GLib.VariantType-getSimpleActionStateType obj = liftIO $ getObjectPropertyBoxed obj "state-type" GLib.VariantType--data SimpleActionStateTypePropertyInfo-instance AttrInfo SimpleActionStateTypePropertyInfo where-    type AttrAllowedOps SimpleActionStateTypePropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint SimpleActionStateTypePropertyInfo = (~) ()-    type AttrBaseTypeConstraint SimpleActionStateTypePropertyInfo = SimpleActionK-    type AttrGetType SimpleActionStateTypePropertyInfo = GLib.VariantType-    type AttrLabel SimpleActionStateTypePropertyInfo = "SimpleAction::state-type"-    attrGet _ = getSimpleActionStateType-    attrSet _ = undefined-    attrConstruct _ = undefined--type instance AttributeList SimpleAction = '[ '("state-type", SimpleActionStateTypePropertyInfo)]--type instance AttributeList SimpleActionGroup = '[ ]--type instance AttributeList SimpleAsyncResult = '[ ]----- XXX Duplicated object with different types:-  --- Name {namespace = "Gio", name = "SimpleIOStream"} -> Property {propName = "input-stream", propType = TInterface "Gio" "InputStream", propFlags = [PropertyReadable,PropertyWritable,PropertyConstructOnly], propTransfer = TransferNothing, propDeprecated = Nothing}-  --- Name {namespace = "Gio", name = "IOStream"} -> Property {propName = "input-stream", propType = TInterface "Gio" "InputStream", propFlags = [PropertyReadable], propTransfer = TransferNothing, propDeprecated = Nothing}---- XXX Duplicated object with different types:-  --- Name {namespace = "Gio", name = "SimpleIOStream"} -> Property {propName = "output-stream", propType = TInterface "Gio" "OutputStream", propFlags = [PropertyReadable,PropertyWritable,PropertyConstructOnly], propTransfer = TransferNothing, propDeprecated = Nothing}-  --- Name {namespace = "Gio", name = "IOStream"} -> Property {propName = "output-stream", propType = TInterface "Gio" "OutputStream", propFlags = [PropertyReadable], propTransfer = TransferNothing, propDeprecated = Nothing}--- VVV Prop "input-stream"-   -- Type: TInterface "Gio" "InputStream"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getSimpleIOStreamInputStream :: (MonadIO m, SimpleIOStreamK o) => o -> m InputStream-getSimpleIOStreamInputStream obj = liftIO $ getObjectPropertyObject obj "input-stream" InputStream--constructSimpleIOStreamInputStream :: (InputStreamK a) => a -> IO ([Char], GValue)-constructSimpleIOStreamInputStream val = constructObjectPropertyObject "input-stream" val--data SimpleIOStreamInputStreamPropertyInfo-instance AttrInfo SimpleIOStreamInputStreamPropertyInfo where-    type AttrAllowedOps SimpleIOStreamInputStreamPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SimpleIOStreamInputStreamPropertyInfo = InputStreamK-    type AttrBaseTypeConstraint SimpleIOStreamInputStreamPropertyInfo = SimpleIOStreamK-    type AttrGetType SimpleIOStreamInputStreamPropertyInfo = InputStream-    type AttrLabel SimpleIOStreamInputStreamPropertyInfo = "SimpleIOStream::input-stream"-    attrGet _ = getSimpleIOStreamInputStream-    attrSet _ = undefined-    attrConstruct _ = constructSimpleIOStreamInputStream---- VVV Prop "output-stream"-   -- Type: TInterface "Gio" "OutputStream"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getSimpleIOStreamOutputStream :: (MonadIO m, SimpleIOStreamK o) => o -> m OutputStream-getSimpleIOStreamOutputStream obj = liftIO $ getObjectPropertyObject obj "output-stream" OutputStream--constructSimpleIOStreamOutputStream :: (OutputStreamK a) => a -> IO ([Char], GValue)-constructSimpleIOStreamOutputStream val = constructObjectPropertyObject "output-stream" val--data SimpleIOStreamOutputStreamPropertyInfo-instance AttrInfo SimpleIOStreamOutputStreamPropertyInfo where-    type AttrAllowedOps SimpleIOStreamOutputStreamPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SimpleIOStreamOutputStreamPropertyInfo = OutputStreamK-    type AttrBaseTypeConstraint SimpleIOStreamOutputStreamPropertyInfo = SimpleIOStreamK-    type AttrGetType SimpleIOStreamOutputStreamPropertyInfo = OutputStream-    type AttrLabel SimpleIOStreamOutputStreamPropertyInfo = "SimpleIOStream::output-stream"-    attrGet _ = getSimpleIOStreamOutputStream-    attrSet _ = undefined-    attrConstruct _ = constructSimpleIOStreamOutputStream--type instance AttributeList SimpleIOStream = '[ '("closed", IOStreamClosedPropertyInfo)]--type instance AttributeList SimplePermission = '[ '("allowed", PermissionAllowedPropertyInfo), '("can-acquire", PermissionCanAcquirePropertyInfo), '("can-release", PermissionCanReleasePropertyInfo)]---- VVV Prop "default-proxy"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable]--getSimpleProxyResolverDefaultProxy :: (MonadIO m, SimpleProxyResolverK o) => o -> m T.Text-getSimpleProxyResolverDefaultProxy obj = liftIO $ getObjectPropertyString obj "default-proxy"--setSimpleProxyResolverDefaultProxy :: (MonadIO m, SimpleProxyResolverK o) => o -> T.Text -> m ()-setSimpleProxyResolverDefaultProxy obj val = liftIO $ setObjectPropertyString obj "default-proxy" val--constructSimpleProxyResolverDefaultProxy :: T.Text -> IO ([Char], GValue)-constructSimpleProxyResolverDefaultProxy val = constructObjectPropertyString "default-proxy" val--data SimpleProxyResolverDefaultProxyPropertyInfo-instance AttrInfo SimpleProxyResolverDefaultProxyPropertyInfo where-    type AttrAllowedOps SimpleProxyResolverDefaultProxyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SimpleProxyResolverDefaultProxyPropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint SimpleProxyResolverDefaultProxyPropertyInfo = SimpleProxyResolverK-    type AttrGetType SimpleProxyResolverDefaultProxyPropertyInfo = T.Text-    type AttrLabel SimpleProxyResolverDefaultProxyPropertyInfo = "SimpleProxyResolver::default-proxy"-    attrGet _ = getSimpleProxyResolverDefaultProxy-    attrSet _ = setSimpleProxyResolverDefaultProxy-    attrConstruct _ = constructSimpleProxyResolverDefaultProxy---- VVV Prop "ignore-hosts"-   -- Type: TCArray True (-1) (-1) (TBasicType TUTF8)-   -- Flags: [PropertyReadable,PropertyWritable]--getSimpleProxyResolverIgnoreHosts :: (MonadIO m, SimpleProxyResolverK o) => o -> m [T.Text]-getSimpleProxyResolverIgnoreHosts obj = liftIO $ getObjectPropertyStringArray obj "ignore-hosts"--setSimpleProxyResolverIgnoreHosts :: (MonadIO m, SimpleProxyResolverK o) => o -> [T.Text] -> m ()-setSimpleProxyResolverIgnoreHosts obj val = liftIO $ setObjectPropertyStringArray obj "ignore-hosts" val--constructSimpleProxyResolverIgnoreHosts :: [T.Text] -> IO ([Char], GValue)-constructSimpleProxyResolverIgnoreHosts val = constructObjectPropertyStringArray "ignore-hosts" val--data SimpleProxyResolverIgnoreHostsPropertyInfo-instance AttrInfo SimpleProxyResolverIgnoreHostsPropertyInfo where-    type AttrAllowedOps SimpleProxyResolverIgnoreHostsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SimpleProxyResolverIgnoreHostsPropertyInfo = (~) [T.Text]-    type AttrBaseTypeConstraint SimpleProxyResolverIgnoreHostsPropertyInfo = SimpleProxyResolverK-    type AttrGetType SimpleProxyResolverIgnoreHostsPropertyInfo = [T.Text]-    type AttrLabel SimpleProxyResolverIgnoreHostsPropertyInfo = "SimpleProxyResolver::ignore-hosts"-    attrGet _ = getSimpleProxyResolverIgnoreHosts-    attrSet _ = setSimpleProxyResolverIgnoreHosts-    attrConstruct _ = constructSimpleProxyResolverIgnoreHosts--type instance AttributeList SimpleProxyResolver = '[ '("default-proxy", SimpleProxyResolverDefaultProxyPropertyInfo), '("ignore-hosts", SimpleProxyResolverIgnoreHostsPropertyInfo)]---- VVV Prop "blocking"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable,PropertyWritable]--getSocketBlocking :: (MonadIO m, SocketK o) => o -> m Bool-getSocketBlocking obj = liftIO $ getObjectPropertyBool obj "blocking"--setSocketBlocking :: (MonadIO m, SocketK o) => o -> Bool -> m ()-setSocketBlocking obj val = liftIO $ setObjectPropertyBool obj "blocking" val--constructSocketBlocking :: Bool -> IO ([Char], GValue)-constructSocketBlocking val = constructObjectPropertyBool "blocking" val--data SocketBlockingPropertyInfo-instance AttrInfo SocketBlockingPropertyInfo where-    type AttrAllowedOps SocketBlockingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SocketBlockingPropertyInfo = (~) Bool-    type AttrBaseTypeConstraint SocketBlockingPropertyInfo = SocketK-    type AttrGetType SocketBlockingPropertyInfo = Bool-    type AttrLabel SocketBlockingPropertyInfo = "Socket::blocking"-    attrGet _ = getSocketBlocking-    attrSet _ = setSocketBlocking-    attrConstruct _ = constructSocketBlocking---- VVV Prop "broadcast"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable,PropertyWritable]--getSocketBroadcast :: (MonadIO m, SocketK o) => o -> m Bool-getSocketBroadcast obj = liftIO $ getObjectPropertyBool obj "broadcast"--setSocketBroadcast :: (MonadIO m, SocketK o) => o -> Bool -> m ()-setSocketBroadcast obj val = liftIO $ setObjectPropertyBool obj "broadcast" val--constructSocketBroadcast :: Bool -> IO ([Char], GValue)-constructSocketBroadcast val = constructObjectPropertyBool "broadcast" val--data SocketBroadcastPropertyInfo-instance AttrInfo SocketBroadcastPropertyInfo where-    type AttrAllowedOps SocketBroadcastPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SocketBroadcastPropertyInfo = (~) Bool-    type AttrBaseTypeConstraint SocketBroadcastPropertyInfo = SocketK-    type AttrGetType SocketBroadcastPropertyInfo = Bool-    type AttrLabel SocketBroadcastPropertyInfo = "Socket::broadcast"-    attrGet _ = getSocketBroadcast-    attrSet _ = setSocketBroadcast-    attrConstruct _ = constructSocketBroadcast---- VVV Prop "family"-   -- Type: TInterface "Gio" "SocketFamily"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getSocketFamily :: (MonadIO m, SocketK o) => o -> m SocketFamily-getSocketFamily obj = liftIO $ getObjectPropertyEnum obj "family"--constructSocketFamily :: SocketFamily -> IO ([Char], GValue)-constructSocketFamily val = constructObjectPropertyEnum "family" val--data SocketFamilyPropertyInfo-instance AttrInfo SocketFamilyPropertyInfo where-    type AttrAllowedOps SocketFamilyPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SocketFamilyPropertyInfo = (~) SocketFamily-    type AttrBaseTypeConstraint SocketFamilyPropertyInfo = SocketK-    type AttrGetType SocketFamilyPropertyInfo = SocketFamily-    type AttrLabel SocketFamilyPropertyInfo = "Socket::family"-    attrGet _ = getSocketFamily-    attrSet _ = undefined-    attrConstruct _ = constructSocketFamily---- VVV Prop "fd"-   -- Type: TBasicType TInt32-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getSocketFd :: (MonadIO m, SocketK o) => o -> m Int32-getSocketFd obj = liftIO $ getObjectPropertyCInt obj "fd"--constructSocketFd :: Int32 -> IO ([Char], GValue)-constructSocketFd val = constructObjectPropertyCInt "fd" val--data SocketFdPropertyInfo-instance AttrInfo SocketFdPropertyInfo where-    type AttrAllowedOps SocketFdPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SocketFdPropertyInfo = (~) Int32-    type AttrBaseTypeConstraint SocketFdPropertyInfo = SocketK-    type AttrGetType SocketFdPropertyInfo = Int32-    type AttrLabel SocketFdPropertyInfo = "Socket::fd"-    attrGet _ = getSocketFd-    attrSet _ = undefined-    attrConstruct _ = constructSocketFd---- VVV Prop "keepalive"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable,PropertyWritable]--getSocketKeepalive :: (MonadIO m, SocketK o) => o -> m Bool-getSocketKeepalive obj = liftIO $ getObjectPropertyBool obj "keepalive"--setSocketKeepalive :: (MonadIO m, SocketK o) => o -> Bool -> m ()-setSocketKeepalive obj val = liftIO $ setObjectPropertyBool obj "keepalive" val--constructSocketKeepalive :: Bool -> IO ([Char], GValue)-constructSocketKeepalive val = constructObjectPropertyBool "keepalive" val--data SocketKeepalivePropertyInfo-instance AttrInfo SocketKeepalivePropertyInfo where-    type AttrAllowedOps SocketKeepalivePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SocketKeepalivePropertyInfo = (~) Bool-    type AttrBaseTypeConstraint SocketKeepalivePropertyInfo = SocketK-    type AttrGetType SocketKeepalivePropertyInfo = Bool-    type AttrLabel SocketKeepalivePropertyInfo = "Socket::keepalive"-    attrGet _ = getSocketKeepalive-    attrSet _ = setSocketKeepalive-    attrConstruct _ = constructSocketKeepalive---- VVV Prop "listen-backlog"-   -- Type: TBasicType TInt32-   -- Flags: [PropertyReadable,PropertyWritable]--getSocketListenBacklog :: (MonadIO m, SocketK o) => o -> m Int32-getSocketListenBacklog obj = liftIO $ getObjectPropertyCInt obj "listen-backlog"--setSocketListenBacklog :: (MonadIO m, SocketK o) => o -> Int32 -> m ()-setSocketListenBacklog obj val = liftIO $ setObjectPropertyCInt obj "listen-backlog" val--constructSocketListenBacklog :: Int32 -> IO ([Char], GValue)-constructSocketListenBacklog val = constructObjectPropertyCInt "listen-backlog" val--data SocketListenBacklogPropertyInfo-instance AttrInfo SocketListenBacklogPropertyInfo where-    type AttrAllowedOps SocketListenBacklogPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SocketListenBacklogPropertyInfo = (~) Int32-    type AttrBaseTypeConstraint SocketListenBacklogPropertyInfo = SocketK-    type AttrGetType SocketListenBacklogPropertyInfo = Int32-    type AttrLabel SocketListenBacklogPropertyInfo = "Socket::listen-backlog"-    attrGet _ = getSocketListenBacklog-    attrSet _ = setSocketListenBacklog-    attrConstruct _ = constructSocketListenBacklog---- VVV Prop "local-address"-   -- Type: TInterface "Gio" "SocketAddress"-   -- Flags: [PropertyReadable]--getSocketLocalAddress :: (MonadIO m, SocketK o) => o -> m SocketAddress-getSocketLocalAddress obj = liftIO $ getObjectPropertyObject obj "local-address" SocketAddress--data SocketLocalAddressPropertyInfo-instance AttrInfo SocketLocalAddressPropertyInfo where-    type AttrAllowedOps SocketLocalAddressPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint SocketLocalAddressPropertyInfo = (~) ()-    type AttrBaseTypeConstraint SocketLocalAddressPropertyInfo = SocketK-    type AttrGetType SocketLocalAddressPropertyInfo = SocketAddress-    type AttrLabel SocketLocalAddressPropertyInfo = "Socket::local-address"-    attrGet _ = getSocketLocalAddress-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "multicast-loopback"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable,PropertyWritable]--getSocketMulticastLoopback :: (MonadIO m, SocketK o) => o -> m Bool-getSocketMulticastLoopback obj = liftIO $ getObjectPropertyBool obj "multicast-loopback"--setSocketMulticastLoopback :: (MonadIO m, SocketK o) => o -> Bool -> m ()-setSocketMulticastLoopback obj val = liftIO $ setObjectPropertyBool obj "multicast-loopback" val--constructSocketMulticastLoopback :: Bool -> IO ([Char], GValue)-constructSocketMulticastLoopback val = constructObjectPropertyBool "multicast-loopback" val--data SocketMulticastLoopbackPropertyInfo-instance AttrInfo SocketMulticastLoopbackPropertyInfo where-    type AttrAllowedOps SocketMulticastLoopbackPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SocketMulticastLoopbackPropertyInfo = (~) Bool-    type AttrBaseTypeConstraint SocketMulticastLoopbackPropertyInfo = SocketK-    type AttrGetType SocketMulticastLoopbackPropertyInfo = Bool-    type AttrLabel SocketMulticastLoopbackPropertyInfo = "Socket::multicast-loopback"-    attrGet _ = getSocketMulticastLoopback-    attrSet _ = setSocketMulticastLoopback-    attrConstruct _ = constructSocketMulticastLoopback---- VVV Prop "multicast-ttl"-   -- Type: TBasicType TUInt32-   -- Flags: [PropertyReadable,PropertyWritable]--getSocketMulticastTtl :: (MonadIO m, SocketK o) => o -> m Word32-getSocketMulticastTtl obj = liftIO $ getObjectPropertyCUInt obj "multicast-ttl"--setSocketMulticastTtl :: (MonadIO m, SocketK o) => o -> Word32 -> m ()-setSocketMulticastTtl obj val = liftIO $ setObjectPropertyCUInt obj "multicast-ttl" val--constructSocketMulticastTtl :: Word32 -> IO ([Char], GValue)-constructSocketMulticastTtl val = constructObjectPropertyCUInt "multicast-ttl" val--data SocketMulticastTtlPropertyInfo-instance AttrInfo SocketMulticastTtlPropertyInfo where-    type AttrAllowedOps SocketMulticastTtlPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SocketMulticastTtlPropertyInfo = (~) Word32-    type AttrBaseTypeConstraint SocketMulticastTtlPropertyInfo = SocketK-    type AttrGetType SocketMulticastTtlPropertyInfo = Word32-    type AttrLabel SocketMulticastTtlPropertyInfo = "Socket::multicast-ttl"-    attrGet _ = getSocketMulticastTtl-    attrSet _ = setSocketMulticastTtl-    attrConstruct _ = constructSocketMulticastTtl---- VVV Prop "protocol"-   -- Type: TInterface "Gio" "SocketProtocol"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getSocketProtocol :: (MonadIO m, SocketK o) => o -> m SocketProtocol-getSocketProtocol obj = liftIO $ getObjectPropertyEnum obj "protocol"--constructSocketProtocol :: SocketProtocol -> IO ([Char], GValue)-constructSocketProtocol val = constructObjectPropertyEnum "protocol" val--data SocketProtocolPropertyInfo-instance AttrInfo SocketProtocolPropertyInfo where-    type AttrAllowedOps SocketProtocolPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SocketProtocolPropertyInfo = (~) SocketProtocol-    type AttrBaseTypeConstraint SocketProtocolPropertyInfo = SocketK-    type AttrGetType SocketProtocolPropertyInfo = SocketProtocol-    type AttrLabel SocketProtocolPropertyInfo = "Socket::protocol"-    attrGet _ = getSocketProtocol-    attrSet _ = undefined-    attrConstruct _ = constructSocketProtocol---- VVV Prop "remote-address"-   -- Type: TInterface "Gio" "SocketAddress"-   -- Flags: [PropertyReadable]--getSocketRemoteAddress :: (MonadIO m, SocketK o) => o -> m SocketAddress-getSocketRemoteAddress obj = liftIO $ getObjectPropertyObject obj "remote-address" SocketAddress--data SocketRemoteAddressPropertyInfo-instance AttrInfo SocketRemoteAddressPropertyInfo where-    type AttrAllowedOps SocketRemoteAddressPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint SocketRemoteAddressPropertyInfo = (~) ()-    type AttrBaseTypeConstraint SocketRemoteAddressPropertyInfo = SocketK-    type AttrGetType SocketRemoteAddressPropertyInfo = SocketAddress-    type AttrLabel SocketRemoteAddressPropertyInfo = "Socket::remote-address"-    attrGet _ = getSocketRemoteAddress-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "timeout"-   -- Type: TBasicType TUInt32-   -- Flags: [PropertyReadable,PropertyWritable]--getSocketTimeout :: (MonadIO m, SocketK o) => o -> m Word32-getSocketTimeout obj = liftIO $ getObjectPropertyCUInt obj "timeout"--setSocketTimeout :: (MonadIO m, SocketK o) => o -> Word32 -> m ()-setSocketTimeout obj val = liftIO $ setObjectPropertyCUInt obj "timeout" val--constructSocketTimeout :: Word32 -> IO ([Char], GValue)-constructSocketTimeout val = constructObjectPropertyCUInt "timeout" val--data SocketTimeoutPropertyInfo-instance AttrInfo SocketTimeoutPropertyInfo where-    type AttrAllowedOps SocketTimeoutPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SocketTimeoutPropertyInfo = (~) Word32-    type AttrBaseTypeConstraint SocketTimeoutPropertyInfo = SocketK-    type AttrGetType SocketTimeoutPropertyInfo = Word32-    type AttrLabel SocketTimeoutPropertyInfo = "Socket::timeout"-    attrGet _ = getSocketTimeout-    attrSet _ = setSocketTimeout-    attrConstruct _ = constructSocketTimeout---- VVV Prop "ttl"-   -- Type: TBasicType TUInt32-   -- Flags: [PropertyReadable,PropertyWritable]--getSocketTtl :: (MonadIO m, SocketK o) => o -> m Word32-getSocketTtl obj = liftIO $ getObjectPropertyCUInt obj "ttl"--setSocketTtl :: (MonadIO m, SocketK o) => o -> Word32 -> m ()-setSocketTtl obj val = liftIO $ setObjectPropertyCUInt obj "ttl" val--constructSocketTtl :: Word32 -> IO ([Char], GValue)-constructSocketTtl val = constructObjectPropertyCUInt "ttl" val--data SocketTtlPropertyInfo-instance AttrInfo SocketTtlPropertyInfo where-    type AttrAllowedOps SocketTtlPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SocketTtlPropertyInfo = (~) Word32-    type AttrBaseTypeConstraint SocketTtlPropertyInfo = SocketK-    type AttrGetType SocketTtlPropertyInfo = Word32-    type AttrLabel SocketTtlPropertyInfo = "Socket::ttl"-    attrGet _ = getSocketTtl-    attrSet _ = setSocketTtl-    attrConstruct _ = constructSocketTtl---- VVV Prop "type"-   -- Type: TInterface "Gio" "SocketType"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getSocketType :: (MonadIO m, SocketK o) => o -> m SocketType-getSocketType obj = liftIO $ getObjectPropertyEnum obj "type"--constructSocketType :: SocketType -> IO ([Char], GValue)-constructSocketType val = constructObjectPropertyEnum "type" val--data SocketTypePropertyInfo-instance AttrInfo SocketTypePropertyInfo where-    type AttrAllowedOps SocketTypePropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SocketTypePropertyInfo = (~) SocketType-    type AttrBaseTypeConstraint SocketTypePropertyInfo = SocketK-    type AttrGetType SocketTypePropertyInfo = SocketType-    type AttrLabel SocketTypePropertyInfo = "Socket::type"-    attrGet _ = getSocketType-    attrSet _ = undefined-    attrConstruct _ = constructSocketType--type instance AttributeList Socket = '[ '("blocking", SocketBlockingPropertyInfo), '("broadcast", SocketBroadcastPropertyInfo), '("family", SocketFamilyPropertyInfo), '("fd", SocketFdPropertyInfo), '("keepalive", SocketKeepalivePropertyInfo), '("listen-backlog", SocketListenBacklogPropertyInfo), '("local-address", SocketLocalAddressPropertyInfo), '("multicast-loopback", SocketMulticastLoopbackPropertyInfo), '("multicast-ttl", SocketMulticastTtlPropertyInfo), '("protocol", SocketProtocolPropertyInfo), '("remote-address", SocketRemoteAddressPropertyInfo), '("timeout", SocketTimeoutPropertyInfo), '("ttl", SocketTtlPropertyInfo), '("type", SocketTypePropertyInfo)]---- VVV Prop "family"-   -- Type: TInterface "Gio" "SocketFamily"-   -- Flags: [PropertyReadable]--getSocketAddressFamily :: (MonadIO m, SocketAddressK o) => o -> m SocketFamily-getSocketAddressFamily obj = liftIO $ getObjectPropertyEnum obj "family"--data SocketAddressFamilyPropertyInfo-instance AttrInfo SocketAddressFamilyPropertyInfo where-    type AttrAllowedOps SocketAddressFamilyPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint SocketAddressFamilyPropertyInfo = (~) ()-    type AttrBaseTypeConstraint SocketAddressFamilyPropertyInfo = SocketAddressK-    type AttrGetType SocketAddressFamilyPropertyInfo = SocketFamily-    type AttrLabel SocketAddressFamilyPropertyInfo = "SocketAddress::family"-    attrGet _ = getSocketAddressFamily-    attrSet _ = undefined-    attrConstruct _ = undefined--type instance AttributeList SocketAddress = '[ '("family", SocketAddressFamilyPropertyInfo)]--type instance AttributeList SocketAddressEnumerator = '[ ]---- VVV Prop "enable-proxy"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]--getSocketClientEnableProxy :: (MonadIO m, SocketClientK o) => o -> m Bool-getSocketClientEnableProxy obj = liftIO $ getObjectPropertyBool obj "enable-proxy"--setSocketClientEnableProxy :: (MonadIO m, SocketClientK o) => o -> Bool -> m ()-setSocketClientEnableProxy obj val = liftIO $ setObjectPropertyBool obj "enable-proxy" val--constructSocketClientEnableProxy :: Bool -> IO ([Char], GValue)-constructSocketClientEnableProxy val = constructObjectPropertyBool "enable-proxy" val--data SocketClientEnableProxyPropertyInfo-instance AttrInfo SocketClientEnableProxyPropertyInfo where-    type AttrAllowedOps SocketClientEnableProxyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SocketClientEnableProxyPropertyInfo = (~) Bool-    type AttrBaseTypeConstraint SocketClientEnableProxyPropertyInfo = SocketClientK-    type AttrGetType SocketClientEnableProxyPropertyInfo = Bool-    type AttrLabel SocketClientEnableProxyPropertyInfo = "SocketClient::enable-proxy"-    attrGet _ = getSocketClientEnableProxy-    attrSet _ = setSocketClientEnableProxy-    attrConstruct _ = constructSocketClientEnableProxy---- VVV Prop "family"-   -- Type: TInterface "Gio" "SocketFamily"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]--getSocketClientFamily :: (MonadIO m, SocketClientK o) => o -> m SocketFamily-getSocketClientFamily obj = liftIO $ getObjectPropertyEnum obj "family"--setSocketClientFamily :: (MonadIO m, SocketClientK o) => o -> SocketFamily -> m ()-setSocketClientFamily obj val = liftIO $ setObjectPropertyEnum obj "family" val--constructSocketClientFamily :: SocketFamily -> IO ([Char], GValue)-constructSocketClientFamily val = constructObjectPropertyEnum "family" val--data SocketClientFamilyPropertyInfo-instance AttrInfo SocketClientFamilyPropertyInfo where-    type AttrAllowedOps SocketClientFamilyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SocketClientFamilyPropertyInfo = (~) SocketFamily-    type AttrBaseTypeConstraint SocketClientFamilyPropertyInfo = SocketClientK-    type AttrGetType SocketClientFamilyPropertyInfo = SocketFamily-    type AttrLabel SocketClientFamilyPropertyInfo = "SocketClient::family"-    attrGet _ = getSocketClientFamily-    attrSet _ = setSocketClientFamily-    attrConstruct _ = constructSocketClientFamily---- VVV Prop "local-address"-   -- Type: TInterface "Gio" "SocketAddress"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]--getSocketClientLocalAddress :: (MonadIO m, SocketClientK o) => o -> m SocketAddress-getSocketClientLocalAddress obj = liftIO $ getObjectPropertyObject obj "local-address" SocketAddress--setSocketClientLocalAddress :: (MonadIO m, SocketClientK o, SocketAddressK a) => o -> a -> m ()-setSocketClientLocalAddress obj val = liftIO $ setObjectPropertyObject obj "local-address" val--constructSocketClientLocalAddress :: (SocketAddressK a) => a -> IO ([Char], GValue)-constructSocketClientLocalAddress val = constructObjectPropertyObject "local-address" val--data SocketClientLocalAddressPropertyInfo-instance AttrInfo SocketClientLocalAddressPropertyInfo where-    type AttrAllowedOps SocketClientLocalAddressPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SocketClientLocalAddressPropertyInfo = SocketAddressK-    type AttrBaseTypeConstraint SocketClientLocalAddressPropertyInfo = SocketClientK-    type AttrGetType SocketClientLocalAddressPropertyInfo = SocketAddress-    type AttrLabel SocketClientLocalAddressPropertyInfo = "SocketClient::local-address"-    attrGet _ = getSocketClientLocalAddress-    attrSet _ = setSocketClientLocalAddress-    attrConstruct _ = constructSocketClientLocalAddress---- VVV Prop "protocol"-   -- Type: TInterface "Gio" "SocketProtocol"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]--getSocketClientProtocol :: (MonadIO m, SocketClientK o) => o -> m SocketProtocol-getSocketClientProtocol obj = liftIO $ getObjectPropertyEnum obj "protocol"--setSocketClientProtocol :: (MonadIO m, SocketClientK o) => o -> SocketProtocol -> m ()-setSocketClientProtocol obj val = liftIO $ setObjectPropertyEnum obj "protocol" val--constructSocketClientProtocol :: SocketProtocol -> IO ([Char], GValue)-constructSocketClientProtocol val = constructObjectPropertyEnum "protocol" val--data SocketClientProtocolPropertyInfo-instance AttrInfo SocketClientProtocolPropertyInfo where-    type AttrAllowedOps SocketClientProtocolPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SocketClientProtocolPropertyInfo = (~) SocketProtocol-    type AttrBaseTypeConstraint SocketClientProtocolPropertyInfo = SocketClientK-    type AttrGetType SocketClientProtocolPropertyInfo = SocketProtocol-    type AttrLabel SocketClientProtocolPropertyInfo = "SocketClient::protocol"-    attrGet _ = getSocketClientProtocol-    attrSet _ = setSocketClientProtocol-    attrConstruct _ = constructSocketClientProtocol---- VVV Prop "proxy-resolver"-   -- Type: TInterface "Gio" "ProxyResolver"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]--getSocketClientProxyResolver :: (MonadIO m, SocketClientK o) => o -> m ProxyResolver-getSocketClientProxyResolver obj = liftIO $ getObjectPropertyObject obj "proxy-resolver" ProxyResolver--setSocketClientProxyResolver :: (MonadIO m, SocketClientK o, ProxyResolverK a) => o -> a -> m ()-setSocketClientProxyResolver obj val = liftIO $ setObjectPropertyObject obj "proxy-resolver" val--constructSocketClientProxyResolver :: (ProxyResolverK a) => a -> IO ([Char], GValue)-constructSocketClientProxyResolver val = constructObjectPropertyObject "proxy-resolver" val--data SocketClientProxyResolverPropertyInfo-instance AttrInfo SocketClientProxyResolverPropertyInfo where-    type AttrAllowedOps SocketClientProxyResolverPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SocketClientProxyResolverPropertyInfo = ProxyResolverK-    type AttrBaseTypeConstraint SocketClientProxyResolverPropertyInfo = SocketClientK-    type AttrGetType SocketClientProxyResolverPropertyInfo = ProxyResolver-    type AttrLabel SocketClientProxyResolverPropertyInfo = "SocketClient::proxy-resolver"-    attrGet _ = getSocketClientProxyResolver-    attrSet _ = setSocketClientProxyResolver-    attrConstruct _ = constructSocketClientProxyResolver---- VVV Prop "timeout"-   -- Type: TBasicType TUInt32-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]--getSocketClientTimeout :: (MonadIO m, SocketClientK o) => o -> m Word32-getSocketClientTimeout obj = liftIO $ getObjectPropertyCUInt obj "timeout"--setSocketClientTimeout :: (MonadIO m, SocketClientK o) => o -> Word32 -> m ()-setSocketClientTimeout obj val = liftIO $ setObjectPropertyCUInt obj "timeout" val--constructSocketClientTimeout :: Word32 -> IO ([Char], GValue)-constructSocketClientTimeout val = constructObjectPropertyCUInt "timeout" val--data SocketClientTimeoutPropertyInfo-instance AttrInfo SocketClientTimeoutPropertyInfo where-    type AttrAllowedOps SocketClientTimeoutPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SocketClientTimeoutPropertyInfo = (~) Word32-    type AttrBaseTypeConstraint SocketClientTimeoutPropertyInfo = SocketClientK-    type AttrGetType SocketClientTimeoutPropertyInfo = Word32-    type AttrLabel SocketClientTimeoutPropertyInfo = "SocketClient::timeout"-    attrGet _ = getSocketClientTimeout-    attrSet _ = setSocketClientTimeout-    attrConstruct _ = constructSocketClientTimeout---- VVV Prop "tls"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]--getSocketClientTls :: (MonadIO m, SocketClientK o) => o -> m Bool-getSocketClientTls obj = liftIO $ getObjectPropertyBool obj "tls"--setSocketClientTls :: (MonadIO m, SocketClientK o) => o -> Bool -> m ()-setSocketClientTls obj val = liftIO $ setObjectPropertyBool obj "tls" val--constructSocketClientTls :: Bool -> IO ([Char], GValue)-constructSocketClientTls val = constructObjectPropertyBool "tls" val--data SocketClientTlsPropertyInfo-instance AttrInfo SocketClientTlsPropertyInfo where-    type AttrAllowedOps SocketClientTlsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SocketClientTlsPropertyInfo = (~) Bool-    type AttrBaseTypeConstraint SocketClientTlsPropertyInfo = SocketClientK-    type AttrGetType SocketClientTlsPropertyInfo = Bool-    type AttrLabel SocketClientTlsPropertyInfo = "SocketClient::tls"-    attrGet _ = getSocketClientTls-    attrSet _ = setSocketClientTls-    attrConstruct _ = constructSocketClientTls---- VVV Prop "tls-validation-flags"-   -- Type: TInterface "Gio" "TlsCertificateFlags"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]--getSocketClientTlsValidationFlags :: (MonadIO m, SocketClientK o) => o -> m [TlsCertificateFlags]-getSocketClientTlsValidationFlags obj = liftIO $ getObjectPropertyFlags obj "tls-validation-flags"--setSocketClientTlsValidationFlags :: (MonadIO m, SocketClientK o) => o -> [TlsCertificateFlags] -> m ()-setSocketClientTlsValidationFlags obj val = liftIO $ setObjectPropertyFlags obj "tls-validation-flags" val--constructSocketClientTlsValidationFlags :: [TlsCertificateFlags] -> IO ([Char], GValue)-constructSocketClientTlsValidationFlags val = constructObjectPropertyFlags "tls-validation-flags" val--data SocketClientTlsValidationFlagsPropertyInfo-instance AttrInfo SocketClientTlsValidationFlagsPropertyInfo where-    type AttrAllowedOps SocketClientTlsValidationFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SocketClientTlsValidationFlagsPropertyInfo = (~) [TlsCertificateFlags]-    type AttrBaseTypeConstraint SocketClientTlsValidationFlagsPropertyInfo = SocketClientK-    type AttrGetType SocketClientTlsValidationFlagsPropertyInfo = [TlsCertificateFlags]-    type AttrLabel SocketClientTlsValidationFlagsPropertyInfo = "SocketClient::tls-validation-flags"-    attrGet _ = getSocketClientTlsValidationFlags-    attrSet _ = setSocketClientTlsValidationFlags-    attrConstruct _ = constructSocketClientTlsValidationFlags---- VVV Prop "type"-   -- Type: TInterface "Gio" "SocketType"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]--getSocketClientType :: (MonadIO m, SocketClientK o) => o -> m SocketType-getSocketClientType obj = liftIO $ getObjectPropertyEnum obj "type"--setSocketClientType :: (MonadIO m, SocketClientK o) => o -> SocketType -> m ()-setSocketClientType obj val = liftIO $ setObjectPropertyEnum obj "type" val--constructSocketClientType :: SocketType -> IO ([Char], GValue)-constructSocketClientType val = constructObjectPropertyEnum "type" val--data SocketClientTypePropertyInfo-instance AttrInfo SocketClientTypePropertyInfo where-    type AttrAllowedOps SocketClientTypePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SocketClientTypePropertyInfo = (~) SocketType-    type AttrBaseTypeConstraint SocketClientTypePropertyInfo = SocketClientK-    type AttrGetType SocketClientTypePropertyInfo = SocketType-    type AttrLabel SocketClientTypePropertyInfo = "SocketClient::type"-    attrGet _ = getSocketClientType-    attrSet _ = setSocketClientType-    attrConstruct _ = constructSocketClientType--type instance AttributeList SocketClient = '[ '("enable-proxy", SocketClientEnableProxyPropertyInfo), '("family", SocketClientFamilyPropertyInfo), '("local-address", SocketClientLocalAddressPropertyInfo), '("protocol", SocketClientProtocolPropertyInfo), '("proxy-resolver", SocketClientProxyResolverPropertyInfo), '("timeout", SocketClientTimeoutPropertyInfo), '("tls", SocketClientTlsPropertyInfo), '("tls-validation-flags", SocketClientTlsValidationFlagsPropertyInfo), '("type", SocketClientTypePropertyInfo)]--type instance AttributeList SocketConnectable = '[ ]---- VVV Prop "socket"-   -- Type: TInterface "Gio" "Socket"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getSocketConnectionSocket :: (MonadIO m, SocketConnectionK o) => o -> m Socket-getSocketConnectionSocket obj = liftIO $ getObjectPropertyObject obj "socket" Socket--constructSocketConnectionSocket :: (SocketK a) => a -> IO ([Char], GValue)-constructSocketConnectionSocket val = constructObjectPropertyObject "socket" val--data SocketConnectionSocketPropertyInfo-instance AttrInfo SocketConnectionSocketPropertyInfo where-    type AttrAllowedOps SocketConnectionSocketPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SocketConnectionSocketPropertyInfo = SocketK-    type AttrBaseTypeConstraint SocketConnectionSocketPropertyInfo = SocketConnectionK-    type AttrGetType SocketConnectionSocketPropertyInfo = Socket-    type AttrLabel SocketConnectionSocketPropertyInfo = "SocketConnection::socket"-    attrGet _ = getSocketConnectionSocket-    attrSet _ = undefined-    attrConstruct _ = constructSocketConnectionSocket--type instance AttributeList SocketConnection = '[ '("closed", IOStreamClosedPropertyInfo), '("input-stream", IOStreamInputStreamPropertyInfo), '("output-stream", IOStreamOutputStreamPropertyInfo), '("socket", SocketConnectionSocketPropertyInfo)]--type instance AttributeList SocketControlMessage = '[ ]---- VVV Prop "listen-backlog"-   -- Type: TBasicType TInt32-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]--getSocketListenerListenBacklog :: (MonadIO m, SocketListenerK o) => o -> m Int32-getSocketListenerListenBacklog obj = liftIO $ getObjectPropertyCInt obj "listen-backlog"--setSocketListenerListenBacklog :: (MonadIO m, SocketListenerK o) => o -> Int32 -> m ()-setSocketListenerListenBacklog obj val = liftIO $ setObjectPropertyCInt obj "listen-backlog" val--constructSocketListenerListenBacklog :: Int32 -> IO ([Char], GValue)-constructSocketListenerListenBacklog val = constructObjectPropertyCInt "listen-backlog" val--data SocketListenerListenBacklogPropertyInfo-instance AttrInfo SocketListenerListenBacklogPropertyInfo where-    type AttrAllowedOps SocketListenerListenBacklogPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SocketListenerListenBacklogPropertyInfo = (~) Int32-    type AttrBaseTypeConstraint SocketListenerListenBacklogPropertyInfo = SocketListenerK-    type AttrGetType SocketListenerListenBacklogPropertyInfo = Int32-    type AttrLabel SocketListenerListenBacklogPropertyInfo = "SocketListener::listen-backlog"-    attrGet _ = getSocketListenerListenBacklog-    attrSet _ = setSocketListenerListenBacklog-    attrConstruct _ = constructSocketListenerListenBacklog--type instance AttributeList SocketListener = '[ '("listen-backlog", SocketListenerListenBacklogPropertyInfo)]---- VVV Prop "active"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]--getSocketServiceActive :: (MonadIO m, SocketServiceK o) => o -> m Bool-getSocketServiceActive obj = liftIO $ getObjectPropertyBool obj "active"--setSocketServiceActive :: (MonadIO m, SocketServiceK o) => o -> Bool -> m ()-setSocketServiceActive obj val = liftIO $ setObjectPropertyBool obj "active" val--constructSocketServiceActive :: Bool -> IO ([Char], GValue)-constructSocketServiceActive val = constructObjectPropertyBool "active" val--data SocketServiceActivePropertyInfo-instance AttrInfo SocketServiceActivePropertyInfo where-    type AttrAllowedOps SocketServiceActivePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint SocketServiceActivePropertyInfo = (~) Bool-    type AttrBaseTypeConstraint SocketServiceActivePropertyInfo = SocketServiceK-    type AttrGetType SocketServiceActivePropertyInfo = Bool-    type AttrLabel SocketServiceActivePropertyInfo = "SocketService::active"-    attrGet _ = getSocketServiceActive-    attrSet _ = setSocketServiceActive-    attrConstruct _ = constructSocketServiceActive--type instance AttributeList SocketService = '[ '("active", SocketServiceActivePropertyInfo), '("listen-backlog", SocketListenerListenBacklogPropertyInfo)]---- VVV Prop "argv"-   -- Type: TCArray True (-1) (-1) (TBasicType TUTF8)-   -- Flags: [PropertyWritable,PropertyConstructOnly]--constructSubprocessArgv :: [T.Text] -> IO ([Char], GValue)-constructSubprocessArgv val = constructObjectPropertyStringArray "argv" val--data SubprocessArgvPropertyInfo-instance AttrInfo SubprocessArgvPropertyInfo where-    type AttrAllowedOps SubprocessArgvPropertyInfo = '[ 'AttrConstruct]-    type AttrSetTypeConstraint SubprocessArgvPropertyInfo = (~) [T.Text]-    type AttrBaseTypeConstraint SubprocessArgvPropertyInfo = SubprocessK-    type AttrGetType SubprocessArgvPropertyInfo = ()-    type AttrLabel SubprocessArgvPropertyInfo = "Subprocess::argv"-    attrGet _ = undefined-    attrSet _ = undefined-    attrConstruct _ = constructSubprocessArgv---- VVV Prop "flags"-   -- Type: TInterface "Gio" "SubprocessFlags"-   -- Flags: [PropertyWritable,PropertyConstructOnly]--constructSubprocessFlags :: [SubprocessFlags] -> IO ([Char], GValue)-constructSubprocessFlags val = constructObjectPropertyFlags "flags" val--data SubprocessFlagsPropertyInfo-instance AttrInfo SubprocessFlagsPropertyInfo where-    type AttrAllowedOps SubprocessFlagsPropertyInfo = '[ 'AttrConstruct]-    type AttrSetTypeConstraint SubprocessFlagsPropertyInfo = (~) [SubprocessFlags]-    type AttrBaseTypeConstraint SubprocessFlagsPropertyInfo = SubprocessK-    type AttrGetType SubprocessFlagsPropertyInfo = ()-    type AttrLabel SubprocessFlagsPropertyInfo = "Subprocess::flags"-    attrGet _ = undefined-    attrSet _ = undefined-    attrConstruct _ = constructSubprocessFlags--type instance AttributeList Subprocess = '[ '("argv", SubprocessArgvPropertyInfo), '("flags", SubprocessFlagsPropertyInfo)]---- VVV Prop "flags"-   -- Type: TInterface "Gio" "SubprocessFlags"-   -- Flags: [PropertyWritable,PropertyConstructOnly]--constructSubprocessLauncherFlags :: [SubprocessFlags] -> IO ([Char], GValue)-constructSubprocessLauncherFlags val = constructObjectPropertyFlags "flags" val--data SubprocessLauncherFlagsPropertyInfo-instance AttrInfo SubprocessLauncherFlagsPropertyInfo where-    type AttrAllowedOps SubprocessLauncherFlagsPropertyInfo = '[ 'AttrConstruct]-    type AttrSetTypeConstraint SubprocessLauncherFlagsPropertyInfo = (~) [SubprocessFlags]-    type AttrBaseTypeConstraint SubprocessLauncherFlagsPropertyInfo = SubprocessLauncherK-    type AttrGetType SubprocessLauncherFlagsPropertyInfo = ()-    type AttrLabel SubprocessLauncherFlagsPropertyInfo = "SubprocessLauncher::flags"-    attrGet _ = undefined-    attrSet _ = undefined-    attrConstruct _ = constructSubprocessLauncherFlags--type instance AttributeList SubprocessLauncher = '[ '("flags", SubprocessLauncherFlagsPropertyInfo)]---- VVV Prop "completed"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable]--getTaskCompleted :: (MonadIO m, TaskK o) => o -> m Bool-getTaskCompleted obj = liftIO $ getObjectPropertyBool obj "completed"--data TaskCompletedPropertyInfo-instance AttrInfo TaskCompletedPropertyInfo where-    type AttrAllowedOps TaskCompletedPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint TaskCompletedPropertyInfo = (~) ()-    type AttrBaseTypeConstraint TaskCompletedPropertyInfo = TaskK-    type AttrGetType TaskCompletedPropertyInfo = Bool-    type AttrLabel TaskCompletedPropertyInfo = "Task::completed"-    attrGet _ = getTaskCompleted-    attrSet _ = undefined-    attrConstruct _ = undefined--type instance AttributeList Task = '[ '("completed", TaskCompletedPropertyInfo)]---- VVV Prop "graceful-disconnect"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable,PropertyWritable]--getTcpConnectionGracefulDisconnect :: (MonadIO m, TcpConnectionK o) => o -> m Bool-getTcpConnectionGracefulDisconnect obj = liftIO $ getObjectPropertyBool obj "graceful-disconnect"--setTcpConnectionGracefulDisconnect :: (MonadIO m, TcpConnectionK o) => o -> Bool -> m ()-setTcpConnectionGracefulDisconnect obj val = liftIO $ setObjectPropertyBool obj "graceful-disconnect" val--constructTcpConnectionGracefulDisconnect :: Bool -> IO ([Char], GValue)-constructTcpConnectionGracefulDisconnect val = constructObjectPropertyBool "graceful-disconnect" val--data TcpConnectionGracefulDisconnectPropertyInfo-instance AttrInfo TcpConnectionGracefulDisconnectPropertyInfo where-    type AttrAllowedOps TcpConnectionGracefulDisconnectPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint TcpConnectionGracefulDisconnectPropertyInfo = (~) Bool-    type AttrBaseTypeConstraint TcpConnectionGracefulDisconnectPropertyInfo = TcpConnectionK-    type AttrGetType TcpConnectionGracefulDisconnectPropertyInfo = Bool-    type AttrLabel TcpConnectionGracefulDisconnectPropertyInfo = "TcpConnection::graceful-disconnect"-    attrGet _ = getTcpConnectionGracefulDisconnect-    attrSet _ = setTcpConnectionGracefulDisconnect-    attrConstruct _ = constructTcpConnectionGracefulDisconnect--type instance AttributeList TcpConnection = '[ '("closed", IOStreamClosedPropertyInfo), '("graceful-disconnect", TcpConnectionGracefulDisconnectPropertyInfo), '("input-stream", IOStreamInputStreamPropertyInfo), '("output-stream", IOStreamOutputStreamPropertyInfo), '("socket", SocketConnectionSocketPropertyInfo)]---- VVV Prop "base-io-stream"-   -- Type: TInterface "Gio" "IOStream"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getTcpWrapperConnectionBaseIoStream :: (MonadIO m, TcpWrapperConnectionK o) => o -> m IOStream-getTcpWrapperConnectionBaseIoStream obj = liftIO $ getObjectPropertyObject obj "base-io-stream" IOStream--constructTcpWrapperConnectionBaseIoStream :: (IOStreamK a) => a -> IO ([Char], GValue)-constructTcpWrapperConnectionBaseIoStream val = constructObjectPropertyObject "base-io-stream" val--data TcpWrapperConnectionBaseIoStreamPropertyInfo-instance AttrInfo TcpWrapperConnectionBaseIoStreamPropertyInfo where-    type AttrAllowedOps TcpWrapperConnectionBaseIoStreamPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint TcpWrapperConnectionBaseIoStreamPropertyInfo = IOStreamK-    type AttrBaseTypeConstraint TcpWrapperConnectionBaseIoStreamPropertyInfo = TcpWrapperConnectionK-    type AttrGetType TcpWrapperConnectionBaseIoStreamPropertyInfo = IOStream-    type AttrLabel TcpWrapperConnectionBaseIoStreamPropertyInfo = "TcpWrapperConnection::base-io-stream"-    attrGet _ = getTcpWrapperConnectionBaseIoStream-    attrSet _ = undefined-    attrConstruct _ = constructTcpWrapperConnectionBaseIoStream--type instance AttributeList TcpWrapperConnection = '[ '("base-io-stream", TcpWrapperConnectionBaseIoStreamPropertyInfo), '("closed", IOStreamClosedPropertyInfo), '("graceful-disconnect", TcpConnectionGracefulDisconnectPropertyInfo), '("input-stream", IOStreamInputStreamPropertyInfo), '("output-stream", IOStreamOutputStreamPropertyInfo), '("socket", SocketConnectionSocketPropertyInfo)]---- VVV Prop "flags"-   -- Type: TInterface "Gio" "TestDBusFlags"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getTestDBusFlags :: (MonadIO m, TestDBusK o) => o -> m [TestDBusFlags]-getTestDBusFlags obj = liftIO $ getObjectPropertyFlags obj "flags"--constructTestDBusFlags :: [TestDBusFlags] -> IO ([Char], GValue)-constructTestDBusFlags val = constructObjectPropertyFlags "flags" val--data TestDBusFlagsPropertyInfo-instance AttrInfo TestDBusFlagsPropertyInfo where-    type AttrAllowedOps TestDBusFlagsPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint TestDBusFlagsPropertyInfo = (~) [TestDBusFlags]-    type AttrBaseTypeConstraint TestDBusFlagsPropertyInfo = TestDBusK-    type AttrGetType TestDBusFlagsPropertyInfo = [TestDBusFlags]-    type AttrLabel TestDBusFlagsPropertyInfo = "TestDBus::flags"-    attrGet _ = getTestDBusFlags-    attrSet _ = undefined-    attrConstruct _ = constructTestDBusFlags--type instance AttributeList TestDBus = '[ '("flags", TestDBusFlagsPropertyInfo)]---- VVV Prop "name"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyWritable,PropertyConstructOnly]--constructThemedIconName :: T.Text -> IO ([Char], GValue)-constructThemedIconName val = constructObjectPropertyString "name" val--data ThemedIconNamePropertyInfo-instance AttrInfo ThemedIconNamePropertyInfo where-    type AttrAllowedOps ThemedIconNamePropertyInfo = '[ 'AttrConstruct]-    type AttrSetTypeConstraint ThemedIconNamePropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint ThemedIconNamePropertyInfo = ThemedIconK-    type AttrGetType ThemedIconNamePropertyInfo = ()-    type AttrLabel ThemedIconNamePropertyInfo = "ThemedIcon::name"-    attrGet _ = undefined-    attrSet _ = undefined-    attrConstruct _ = constructThemedIconName---- VVV Prop "names"-   -- Type: TCArray True (-1) (-1) (TBasicType TUTF8)-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getThemedIconNames :: (MonadIO m, ThemedIconK o) => o -> m [T.Text]-getThemedIconNames obj = liftIO $ getObjectPropertyStringArray obj "names"--constructThemedIconNames :: [T.Text] -> IO ([Char], GValue)-constructThemedIconNames val = constructObjectPropertyStringArray "names" val--data ThemedIconNamesPropertyInfo-instance AttrInfo ThemedIconNamesPropertyInfo where-    type AttrAllowedOps ThemedIconNamesPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint ThemedIconNamesPropertyInfo = (~) [T.Text]-    type AttrBaseTypeConstraint ThemedIconNamesPropertyInfo = ThemedIconK-    type AttrGetType ThemedIconNamesPropertyInfo = [T.Text]-    type AttrLabel ThemedIconNamesPropertyInfo = "ThemedIcon::names"-    attrGet _ = getThemedIconNames-    attrSet _ = undefined-    attrConstruct _ = constructThemedIconNames---- VVV Prop "use-default-fallbacks"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getThemedIconUseDefaultFallbacks :: (MonadIO m, ThemedIconK o) => o -> m Bool-getThemedIconUseDefaultFallbacks obj = liftIO $ getObjectPropertyBool obj "use-default-fallbacks"--constructThemedIconUseDefaultFallbacks :: Bool -> IO ([Char], GValue)-constructThemedIconUseDefaultFallbacks val = constructObjectPropertyBool "use-default-fallbacks" val--data ThemedIconUseDefaultFallbacksPropertyInfo-instance AttrInfo ThemedIconUseDefaultFallbacksPropertyInfo where-    type AttrAllowedOps ThemedIconUseDefaultFallbacksPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint ThemedIconUseDefaultFallbacksPropertyInfo = (~) Bool-    type AttrBaseTypeConstraint ThemedIconUseDefaultFallbacksPropertyInfo = ThemedIconK-    type AttrGetType ThemedIconUseDefaultFallbacksPropertyInfo = Bool-    type AttrLabel ThemedIconUseDefaultFallbacksPropertyInfo = "ThemedIcon::use-default-fallbacks"-    attrGet _ = getThemedIconUseDefaultFallbacks-    attrSet _ = undefined-    attrConstruct _ = constructThemedIconUseDefaultFallbacks--type instance AttributeList ThemedIcon = '[ '("name", ThemedIconNamePropertyInfo), '("names", ThemedIconNamesPropertyInfo), '("use-default-fallbacks", ThemedIconUseDefaultFallbacksPropertyInfo)]---- VVV Prop "max-threads"-   -- Type: TBasicType TInt32-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getThreadedSocketServiceMaxThreads :: (MonadIO m, ThreadedSocketServiceK o) => o -> m Int32-getThreadedSocketServiceMaxThreads obj = liftIO $ getObjectPropertyCInt obj "max-threads"--constructThreadedSocketServiceMaxThreads :: Int32 -> IO ([Char], GValue)-constructThreadedSocketServiceMaxThreads val = constructObjectPropertyCInt "max-threads" val--data ThreadedSocketServiceMaxThreadsPropertyInfo-instance AttrInfo ThreadedSocketServiceMaxThreadsPropertyInfo where-    type AttrAllowedOps ThreadedSocketServiceMaxThreadsPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint ThreadedSocketServiceMaxThreadsPropertyInfo = (~) Int32-    type AttrBaseTypeConstraint ThreadedSocketServiceMaxThreadsPropertyInfo = ThreadedSocketServiceK-    type AttrGetType ThreadedSocketServiceMaxThreadsPropertyInfo = Int32-    type AttrLabel ThreadedSocketServiceMaxThreadsPropertyInfo = "ThreadedSocketService::max-threads"-    attrGet _ = getThreadedSocketServiceMaxThreads-    attrSet _ = undefined-    attrConstruct _ = constructThreadedSocketServiceMaxThreads--type instance AttributeList ThreadedSocketService = '[ '("active", SocketServiceActivePropertyInfo), '("listen-backlog", SocketListenerListenBacklogPropertyInfo), '("max-threads", ThreadedSocketServiceMaxThreadsPropertyInfo)]--type instance AttributeList TlsBackend = '[ ]---- VVV Prop "certificate"-   -- Type: TByteArray-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getTlsCertificateCertificate :: (MonadIO m, TlsCertificateK o) => o -> m ByteString-getTlsCertificateCertificate obj = liftIO $ getObjectPropertyByteArray obj "certificate"--constructTlsCertificateCertificate :: ByteString -> IO ([Char], GValue)-constructTlsCertificateCertificate val = constructObjectPropertyByteArray "certificate" val--data TlsCertificateCertificatePropertyInfo-instance AttrInfo TlsCertificateCertificatePropertyInfo where-    type AttrAllowedOps TlsCertificateCertificatePropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint TlsCertificateCertificatePropertyInfo = (~) ByteString-    type AttrBaseTypeConstraint TlsCertificateCertificatePropertyInfo = TlsCertificateK-    type AttrGetType TlsCertificateCertificatePropertyInfo = ByteString-    type AttrLabel TlsCertificateCertificatePropertyInfo = "TlsCertificate::certificate"-    attrGet _ = getTlsCertificateCertificate-    attrSet _ = undefined-    attrConstruct _ = constructTlsCertificateCertificate---- VVV Prop "certificate-pem"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getTlsCertificateCertificatePem :: (MonadIO m, TlsCertificateK o) => o -> m T.Text-getTlsCertificateCertificatePem obj = liftIO $ getObjectPropertyString obj "certificate-pem"--constructTlsCertificateCertificatePem :: T.Text -> IO ([Char], GValue)-constructTlsCertificateCertificatePem val = constructObjectPropertyString "certificate-pem" val--data TlsCertificateCertificatePemPropertyInfo-instance AttrInfo TlsCertificateCertificatePemPropertyInfo where-    type AttrAllowedOps TlsCertificateCertificatePemPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint TlsCertificateCertificatePemPropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint TlsCertificateCertificatePemPropertyInfo = TlsCertificateK-    type AttrGetType TlsCertificateCertificatePemPropertyInfo = T.Text-    type AttrLabel TlsCertificateCertificatePemPropertyInfo = "TlsCertificate::certificate-pem"-    attrGet _ = getTlsCertificateCertificatePem-    attrSet _ = undefined-    attrConstruct _ = constructTlsCertificateCertificatePem---- VVV Prop "issuer"-   -- Type: TInterface "Gio" "TlsCertificate"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getTlsCertificateIssuer :: (MonadIO m, TlsCertificateK o) => o -> m TlsCertificate-getTlsCertificateIssuer obj = liftIO $ getObjectPropertyObject obj "issuer" TlsCertificate--constructTlsCertificateIssuer :: (TlsCertificateK a) => a -> IO ([Char], GValue)-constructTlsCertificateIssuer val = constructObjectPropertyObject "issuer" val--data TlsCertificateIssuerPropertyInfo-instance AttrInfo TlsCertificateIssuerPropertyInfo where-    type AttrAllowedOps TlsCertificateIssuerPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint TlsCertificateIssuerPropertyInfo = TlsCertificateK-    type AttrBaseTypeConstraint TlsCertificateIssuerPropertyInfo = TlsCertificateK-    type AttrGetType TlsCertificateIssuerPropertyInfo = TlsCertificate-    type AttrLabel TlsCertificateIssuerPropertyInfo = "TlsCertificate::issuer"-    attrGet _ = getTlsCertificateIssuer-    attrSet _ = undefined-    attrConstruct _ = constructTlsCertificateIssuer---- VVV Prop "private-key"-   -- Type: TByteArray-   -- Flags: [PropertyWritable,PropertyConstructOnly]--constructTlsCertificatePrivateKey :: ByteString -> IO ([Char], GValue)-constructTlsCertificatePrivateKey val = constructObjectPropertyByteArray "private-key" val--data TlsCertificatePrivateKeyPropertyInfo-instance AttrInfo TlsCertificatePrivateKeyPropertyInfo where-    type AttrAllowedOps TlsCertificatePrivateKeyPropertyInfo = '[ 'AttrConstruct]-    type AttrSetTypeConstraint TlsCertificatePrivateKeyPropertyInfo = (~) ByteString-    type AttrBaseTypeConstraint TlsCertificatePrivateKeyPropertyInfo = TlsCertificateK-    type AttrGetType TlsCertificatePrivateKeyPropertyInfo = ()-    type AttrLabel TlsCertificatePrivateKeyPropertyInfo = "TlsCertificate::private-key"-    attrGet _ = undefined-    attrSet _ = undefined-    attrConstruct _ = constructTlsCertificatePrivateKey---- VVV Prop "private-key-pem"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyWritable,PropertyConstructOnly]--constructTlsCertificatePrivateKeyPem :: T.Text -> IO ([Char], GValue)-constructTlsCertificatePrivateKeyPem val = constructObjectPropertyString "private-key-pem" val--data TlsCertificatePrivateKeyPemPropertyInfo-instance AttrInfo TlsCertificatePrivateKeyPemPropertyInfo where-    type AttrAllowedOps TlsCertificatePrivateKeyPemPropertyInfo = '[ 'AttrConstruct]-    type AttrSetTypeConstraint TlsCertificatePrivateKeyPemPropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint TlsCertificatePrivateKeyPemPropertyInfo = TlsCertificateK-    type AttrGetType TlsCertificatePrivateKeyPemPropertyInfo = ()-    type AttrLabel TlsCertificatePrivateKeyPemPropertyInfo = "TlsCertificate::private-key-pem"-    attrGet _ = undefined-    attrSet _ = undefined-    attrConstruct _ = constructTlsCertificatePrivateKeyPem--type instance AttributeList TlsCertificate = '[ '("certificate", TlsCertificateCertificatePropertyInfo), '("certificate-pem", TlsCertificateCertificatePemPropertyInfo), '("issuer", TlsCertificateIssuerPropertyInfo), '("private-key", TlsCertificatePrivateKeyPropertyInfo), '("private-key-pem", TlsCertificatePrivateKeyPemPropertyInfo)]---- VVV Prop "accepted-cas"-   -- Type: TGList (TBasicType TVoid)-   -- Flags: [PropertyReadable]--getTlsClientConnectionAcceptedCas :: (MonadIO m, TlsClientConnectionK o) => o -> m [Ptr ()]-getTlsClientConnectionAcceptedCas obj = liftIO $ getObjectPropertyPtrGList obj "accepted-cas"--data TlsClientConnectionAcceptedCasPropertyInfo-instance AttrInfo TlsClientConnectionAcceptedCasPropertyInfo where-    type AttrAllowedOps TlsClientConnectionAcceptedCasPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint TlsClientConnectionAcceptedCasPropertyInfo = (~) ()-    type AttrBaseTypeConstraint TlsClientConnectionAcceptedCasPropertyInfo = TlsClientConnectionK-    type AttrGetType TlsClientConnectionAcceptedCasPropertyInfo = ([Ptr ()])-    type AttrLabel TlsClientConnectionAcceptedCasPropertyInfo = "TlsClientConnection::accepted-cas"-    attrGet _ = getTlsClientConnectionAcceptedCas-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "server-identity"-   -- Type: TInterface "Gio" "SocketConnectable"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]--getTlsClientConnectionServerIdentity :: (MonadIO m, TlsClientConnectionK o) => o -> m SocketConnectable-getTlsClientConnectionServerIdentity obj = liftIO $ getObjectPropertyObject obj "server-identity" SocketConnectable--setTlsClientConnectionServerIdentity :: (MonadIO m, TlsClientConnectionK o, SocketConnectableK a) => o -> a -> m ()-setTlsClientConnectionServerIdentity obj val = liftIO $ setObjectPropertyObject obj "server-identity" val--constructTlsClientConnectionServerIdentity :: (SocketConnectableK a) => a -> IO ([Char], GValue)-constructTlsClientConnectionServerIdentity val = constructObjectPropertyObject "server-identity" val--data TlsClientConnectionServerIdentityPropertyInfo-instance AttrInfo TlsClientConnectionServerIdentityPropertyInfo where-    type AttrAllowedOps TlsClientConnectionServerIdentityPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint TlsClientConnectionServerIdentityPropertyInfo = SocketConnectableK-    type AttrBaseTypeConstraint TlsClientConnectionServerIdentityPropertyInfo = TlsClientConnectionK-    type AttrGetType TlsClientConnectionServerIdentityPropertyInfo = SocketConnectable-    type AttrLabel TlsClientConnectionServerIdentityPropertyInfo = "TlsClientConnection::server-identity"-    attrGet _ = getTlsClientConnectionServerIdentity-    attrSet _ = setTlsClientConnectionServerIdentity-    attrConstruct _ = constructTlsClientConnectionServerIdentity---- VVV Prop "use-ssl3"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]--getTlsClientConnectionUseSsl3 :: (MonadIO m, TlsClientConnectionK o) => o -> m Bool-getTlsClientConnectionUseSsl3 obj = liftIO $ getObjectPropertyBool obj "use-ssl3"--setTlsClientConnectionUseSsl3 :: (MonadIO m, TlsClientConnectionK o) => o -> Bool -> m ()-setTlsClientConnectionUseSsl3 obj val = liftIO $ setObjectPropertyBool obj "use-ssl3" val--constructTlsClientConnectionUseSsl3 :: Bool -> IO ([Char], GValue)-constructTlsClientConnectionUseSsl3 val = constructObjectPropertyBool "use-ssl3" val--data TlsClientConnectionUseSsl3PropertyInfo-instance AttrInfo TlsClientConnectionUseSsl3PropertyInfo where-    type AttrAllowedOps TlsClientConnectionUseSsl3PropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint TlsClientConnectionUseSsl3PropertyInfo = (~) Bool-    type AttrBaseTypeConstraint TlsClientConnectionUseSsl3PropertyInfo = TlsClientConnectionK-    type AttrGetType TlsClientConnectionUseSsl3PropertyInfo = Bool-    type AttrLabel TlsClientConnectionUseSsl3PropertyInfo = "TlsClientConnection::use-ssl3"-    attrGet _ = getTlsClientConnectionUseSsl3-    attrSet _ = setTlsClientConnectionUseSsl3-    attrConstruct _ = constructTlsClientConnectionUseSsl3---- VVV Prop "validation-flags"-   -- Type: TInterface "Gio" "TlsCertificateFlags"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]--getTlsClientConnectionValidationFlags :: (MonadIO m, TlsClientConnectionK o) => o -> m [TlsCertificateFlags]-getTlsClientConnectionValidationFlags obj = liftIO $ getObjectPropertyFlags obj "validation-flags"--setTlsClientConnectionValidationFlags :: (MonadIO m, TlsClientConnectionK o) => o -> [TlsCertificateFlags] -> m ()-setTlsClientConnectionValidationFlags obj val = liftIO $ setObjectPropertyFlags obj "validation-flags" val--constructTlsClientConnectionValidationFlags :: [TlsCertificateFlags] -> IO ([Char], GValue)-constructTlsClientConnectionValidationFlags val = constructObjectPropertyFlags "validation-flags" val--data TlsClientConnectionValidationFlagsPropertyInfo-instance AttrInfo TlsClientConnectionValidationFlagsPropertyInfo where-    type AttrAllowedOps TlsClientConnectionValidationFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint TlsClientConnectionValidationFlagsPropertyInfo = (~) [TlsCertificateFlags]-    type AttrBaseTypeConstraint TlsClientConnectionValidationFlagsPropertyInfo = TlsClientConnectionK-    type AttrGetType TlsClientConnectionValidationFlagsPropertyInfo = [TlsCertificateFlags]-    type AttrLabel TlsClientConnectionValidationFlagsPropertyInfo = "TlsClientConnection::validation-flags"-    attrGet _ = getTlsClientConnectionValidationFlags-    attrSet _ = setTlsClientConnectionValidationFlags-    attrConstruct _ = constructTlsClientConnectionValidationFlags--type instance AttributeList TlsClientConnection = '[ '("accepted-cas", TlsClientConnectionAcceptedCasPropertyInfo), '("base-io-stream", TlsConnectionBaseIoStreamPropertyInfo), '("certificate", TlsConnectionCertificatePropertyInfo), '("closed", IOStreamClosedPropertyInfo), '("database", TlsConnectionDatabasePropertyInfo), '("input-stream", IOStreamInputStreamPropertyInfo), '("interaction", TlsConnectionInteractionPropertyInfo), '("output-stream", IOStreamOutputStreamPropertyInfo), '("peer-certificate", TlsConnectionPeerCertificatePropertyInfo), '("peer-certificate-errors", TlsConnectionPeerCertificateErrorsPropertyInfo), '("rehandshake-mode", TlsConnectionRehandshakeModePropertyInfo), '("require-close-notify", TlsConnectionRequireCloseNotifyPropertyInfo), '("server-identity", TlsClientConnectionServerIdentityPropertyInfo), '("use-ssl3", TlsClientConnectionUseSsl3PropertyInfo), '("use-system-certdb", TlsConnectionUseSystemCertdbPropertyInfo), '("validation-flags", TlsClientConnectionValidationFlagsPropertyInfo)]---- VVV Prop "base-io-stream"-   -- Type: TInterface "Gio" "IOStream"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getTlsConnectionBaseIoStream :: (MonadIO m, TlsConnectionK o) => o -> m IOStream-getTlsConnectionBaseIoStream obj = liftIO $ getObjectPropertyObject obj "base-io-stream" IOStream--constructTlsConnectionBaseIoStream :: (IOStreamK a) => a -> IO ([Char], GValue)-constructTlsConnectionBaseIoStream val = constructObjectPropertyObject "base-io-stream" val--data TlsConnectionBaseIoStreamPropertyInfo-instance AttrInfo TlsConnectionBaseIoStreamPropertyInfo where-    type AttrAllowedOps TlsConnectionBaseIoStreamPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint TlsConnectionBaseIoStreamPropertyInfo = IOStreamK-    type AttrBaseTypeConstraint TlsConnectionBaseIoStreamPropertyInfo = TlsConnectionK-    type AttrGetType TlsConnectionBaseIoStreamPropertyInfo = IOStream-    type AttrLabel TlsConnectionBaseIoStreamPropertyInfo = "TlsConnection::base-io-stream"-    attrGet _ = getTlsConnectionBaseIoStream-    attrSet _ = undefined-    attrConstruct _ = constructTlsConnectionBaseIoStream---- VVV Prop "certificate"-   -- Type: TInterface "Gio" "TlsCertificate"-   -- Flags: [PropertyReadable,PropertyWritable]--getTlsConnectionCertificate :: (MonadIO m, TlsConnectionK o) => o -> m TlsCertificate-getTlsConnectionCertificate obj = liftIO $ getObjectPropertyObject obj "certificate" TlsCertificate--setTlsConnectionCertificate :: (MonadIO m, TlsConnectionK o, TlsCertificateK a) => o -> a -> m ()-setTlsConnectionCertificate obj val = liftIO $ setObjectPropertyObject obj "certificate" val--constructTlsConnectionCertificate :: (TlsCertificateK a) => a -> IO ([Char], GValue)-constructTlsConnectionCertificate val = constructObjectPropertyObject "certificate" val--data TlsConnectionCertificatePropertyInfo-instance AttrInfo TlsConnectionCertificatePropertyInfo where-    type AttrAllowedOps TlsConnectionCertificatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint TlsConnectionCertificatePropertyInfo = TlsCertificateK-    type AttrBaseTypeConstraint TlsConnectionCertificatePropertyInfo = TlsConnectionK-    type AttrGetType TlsConnectionCertificatePropertyInfo = TlsCertificate-    type AttrLabel TlsConnectionCertificatePropertyInfo = "TlsConnection::certificate"-    attrGet _ = getTlsConnectionCertificate-    attrSet _ = setTlsConnectionCertificate-    attrConstruct _ = constructTlsConnectionCertificate---- VVV Prop "database"-   -- Type: TInterface "Gio" "TlsDatabase"-   -- Flags: [PropertyReadable,PropertyWritable]--getTlsConnectionDatabase :: (MonadIO m, TlsConnectionK o) => o -> m TlsDatabase-getTlsConnectionDatabase obj = liftIO $ getObjectPropertyObject obj "database" TlsDatabase--setTlsConnectionDatabase :: (MonadIO m, TlsConnectionK o, TlsDatabaseK a) => o -> a -> m ()-setTlsConnectionDatabase obj val = liftIO $ setObjectPropertyObject obj "database" val--constructTlsConnectionDatabase :: (TlsDatabaseK a) => a -> IO ([Char], GValue)-constructTlsConnectionDatabase val = constructObjectPropertyObject "database" val--data TlsConnectionDatabasePropertyInfo-instance AttrInfo TlsConnectionDatabasePropertyInfo where-    type AttrAllowedOps TlsConnectionDatabasePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint TlsConnectionDatabasePropertyInfo = TlsDatabaseK-    type AttrBaseTypeConstraint TlsConnectionDatabasePropertyInfo = TlsConnectionK-    type AttrGetType TlsConnectionDatabasePropertyInfo = TlsDatabase-    type AttrLabel TlsConnectionDatabasePropertyInfo = "TlsConnection::database"-    attrGet _ = getTlsConnectionDatabase-    attrSet _ = setTlsConnectionDatabase-    attrConstruct _ = constructTlsConnectionDatabase---- VVV Prop "interaction"-   -- Type: TInterface "Gio" "TlsInteraction"-   -- Flags: [PropertyReadable,PropertyWritable]--getTlsConnectionInteraction :: (MonadIO m, TlsConnectionK o) => o -> m TlsInteraction-getTlsConnectionInteraction obj = liftIO $ getObjectPropertyObject obj "interaction" TlsInteraction--setTlsConnectionInteraction :: (MonadIO m, TlsConnectionK o, TlsInteractionK a) => o -> a -> m ()-setTlsConnectionInteraction obj val = liftIO $ setObjectPropertyObject obj "interaction" val--constructTlsConnectionInteraction :: (TlsInteractionK a) => a -> IO ([Char], GValue)-constructTlsConnectionInteraction val = constructObjectPropertyObject "interaction" val--data TlsConnectionInteractionPropertyInfo-instance AttrInfo TlsConnectionInteractionPropertyInfo where-    type AttrAllowedOps TlsConnectionInteractionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint TlsConnectionInteractionPropertyInfo = TlsInteractionK-    type AttrBaseTypeConstraint TlsConnectionInteractionPropertyInfo = TlsConnectionK-    type AttrGetType TlsConnectionInteractionPropertyInfo = TlsInteraction-    type AttrLabel TlsConnectionInteractionPropertyInfo = "TlsConnection::interaction"-    attrGet _ = getTlsConnectionInteraction-    attrSet _ = setTlsConnectionInteraction-    attrConstruct _ = constructTlsConnectionInteraction---- VVV Prop "peer-certificate"-   -- Type: TInterface "Gio" "TlsCertificate"-   -- Flags: [PropertyReadable]--getTlsConnectionPeerCertificate :: (MonadIO m, TlsConnectionK o) => o -> m TlsCertificate-getTlsConnectionPeerCertificate obj = liftIO $ getObjectPropertyObject obj "peer-certificate" TlsCertificate--data TlsConnectionPeerCertificatePropertyInfo-instance AttrInfo TlsConnectionPeerCertificatePropertyInfo where-    type AttrAllowedOps TlsConnectionPeerCertificatePropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint TlsConnectionPeerCertificatePropertyInfo = (~) ()-    type AttrBaseTypeConstraint TlsConnectionPeerCertificatePropertyInfo = TlsConnectionK-    type AttrGetType TlsConnectionPeerCertificatePropertyInfo = TlsCertificate-    type AttrLabel TlsConnectionPeerCertificatePropertyInfo = "TlsConnection::peer-certificate"-    attrGet _ = getTlsConnectionPeerCertificate-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "peer-certificate-errors"-   -- Type: TInterface "Gio" "TlsCertificateFlags"-   -- Flags: [PropertyReadable]--getTlsConnectionPeerCertificateErrors :: (MonadIO m, TlsConnectionK o) => o -> m [TlsCertificateFlags]-getTlsConnectionPeerCertificateErrors obj = liftIO $ getObjectPropertyFlags obj "peer-certificate-errors"--data TlsConnectionPeerCertificateErrorsPropertyInfo-instance AttrInfo TlsConnectionPeerCertificateErrorsPropertyInfo where-    type AttrAllowedOps TlsConnectionPeerCertificateErrorsPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint TlsConnectionPeerCertificateErrorsPropertyInfo = (~) ()-    type AttrBaseTypeConstraint TlsConnectionPeerCertificateErrorsPropertyInfo = TlsConnectionK-    type AttrGetType TlsConnectionPeerCertificateErrorsPropertyInfo = [TlsCertificateFlags]-    type AttrLabel TlsConnectionPeerCertificateErrorsPropertyInfo = "TlsConnection::peer-certificate-errors"-    attrGet _ = getTlsConnectionPeerCertificateErrors-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "rehandshake-mode"-   -- Type: TInterface "Gio" "TlsRehandshakeMode"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]--getTlsConnectionRehandshakeMode :: (MonadIO m, TlsConnectionK o) => o -> m TlsRehandshakeMode-getTlsConnectionRehandshakeMode obj = liftIO $ getObjectPropertyEnum obj "rehandshake-mode"--setTlsConnectionRehandshakeMode :: (MonadIO m, TlsConnectionK o) => o -> TlsRehandshakeMode -> m ()-setTlsConnectionRehandshakeMode obj val = liftIO $ setObjectPropertyEnum obj "rehandshake-mode" val--constructTlsConnectionRehandshakeMode :: TlsRehandshakeMode -> IO ([Char], GValue)-constructTlsConnectionRehandshakeMode val = constructObjectPropertyEnum "rehandshake-mode" val--data TlsConnectionRehandshakeModePropertyInfo-instance AttrInfo TlsConnectionRehandshakeModePropertyInfo where-    type AttrAllowedOps TlsConnectionRehandshakeModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint TlsConnectionRehandshakeModePropertyInfo = (~) TlsRehandshakeMode-    type AttrBaseTypeConstraint TlsConnectionRehandshakeModePropertyInfo = TlsConnectionK-    type AttrGetType TlsConnectionRehandshakeModePropertyInfo = TlsRehandshakeMode-    type AttrLabel TlsConnectionRehandshakeModePropertyInfo = "TlsConnection::rehandshake-mode"-    attrGet _ = getTlsConnectionRehandshakeMode-    attrSet _ = setTlsConnectionRehandshakeMode-    attrConstruct _ = constructTlsConnectionRehandshakeMode---- VVV Prop "require-close-notify"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]--getTlsConnectionRequireCloseNotify :: (MonadIO m, TlsConnectionK o) => o -> m Bool-getTlsConnectionRequireCloseNotify obj = liftIO $ getObjectPropertyBool obj "require-close-notify"--setTlsConnectionRequireCloseNotify :: (MonadIO m, TlsConnectionK o) => o -> Bool -> m ()-setTlsConnectionRequireCloseNotify obj val = liftIO $ setObjectPropertyBool obj "require-close-notify" val--constructTlsConnectionRequireCloseNotify :: Bool -> IO ([Char], GValue)-constructTlsConnectionRequireCloseNotify val = constructObjectPropertyBool "require-close-notify" val--data TlsConnectionRequireCloseNotifyPropertyInfo-instance AttrInfo TlsConnectionRequireCloseNotifyPropertyInfo where-    type AttrAllowedOps TlsConnectionRequireCloseNotifyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint TlsConnectionRequireCloseNotifyPropertyInfo = (~) Bool-    type AttrBaseTypeConstraint TlsConnectionRequireCloseNotifyPropertyInfo = TlsConnectionK-    type AttrGetType TlsConnectionRequireCloseNotifyPropertyInfo = Bool-    type AttrLabel TlsConnectionRequireCloseNotifyPropertyInfo = "TlsConnection::require-close-notify"-    attrGet _ = getTlsConnectionRequireCloseNotify-    attrSet _ = setTlsConnectionRequireCloseNotify-    attrConstruct _ = constructTlsConnectionRequireCloseNotify---- VVV Prop "use-system-certdb"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]--getTlsConnectionUseSystemCertdb :: (MonadIO m, TlsConnectionK o) => o -> m Bool-getTlsConnectionUseSystemCertdb obj = liftIO $ getObjectPropertyBool obj "use-system-certdb"--setTlsConnectionUseSystemCertdb :: (MonadIO m, TlsConnectionK o) => o -> Bool -> m ()-setTlsConnectionUseSystemCertdb obj val = liftIO $ setObjectPropertyBool obj "use-system-certdb" val--constructTlsConnectionUseSystemCertdb :: Bool -> IO ([Char], GValue)-constructTlsConnectionUseSystemCertdb val = constructObjectPropertyBool "use-system-certdb" val--data TlsConnectionUseSystemCertdbPropertyInfo-instance AttrInfo TlsConnectionUseSystemCertdbPropertyInfo where-    type AttrAllowedOps TlsConnectionUseSystemCertdbPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint TlsConnectionUseSystemCertdbPropertyInfo = (~) Bool-    type AttrBaseTypeConstraint TlsConnectionUseSystemCertdbPropertyInfo = TlsConnectionK-    type AttrGetType TlsConnectionUseSystemCertdbPropertyInfo = Bool-    type AttrLabel TlsConnectionUseSystemCertdbPropertyInfo = "TlsConnection::use-system-certdb"-    attrGet _ = getTlsConnectionUseSystemCertdb-    attrSet _ = setTlsConnectionUseSystemCertdb-    attrConstruct _ = constructTlsConnectionUseSystemCertdb--type instance AttributeList TlsConnection = '[ '("base-io-stream", TlsConnectionBaseIoStreamPropertyInfo), '("certificate", TlsConnectionCertificatePropertyInfo), '("closed", IOStreamClosedPropertyInfo), '("database", TlsConnectionDatabasePropertyInfo), '("input-stream", IOStreamInputStreamPropertyInfo), '("interaction", TlsConnectionInteractionPropertyInfo), '("output-stream", IOStreamOutputStreamPropertyInfo), '("peer-certificate", TlsConnectionPeerCertificatePropertyInfo), '("peer-certificate-errors", TlsConnectionPeerCertificateErrorsPropertyInfo), '("rehandshake-mode", TlsConnectionRehandshakeModePropertyInfo), '("require-close-notify", TlsConnectionRequireCloseNotifyPropertyInfo), '("use-system-certdb", TlsConnectionUseSystemCertdbPropertyInfo)]--type instance AttributeList TlsDatabase = '[ ]---- VVV Prop "anchors"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]--getTlsFileDatabaseAnchors :: (MonadIO m, TlsFileDatabaseK o) => o -> m T.Text-getTlsFileDatabaseAnchors obj = liftIO $ getObjectPropertyString obj "anchors"--setTlsFileDatabaseAnchors :: (MonadIO m, TlsFileDatabaseK o) => o -> T.Text -> m ()-setTlsFileDatabaseAnchors obj val = liftIO $ setObjectPropertyString obj "anchors" val--constructTlsFileDatabaseAnchors :: T.Text -> IO ([Char], GValue)-constructTlsFileDatabaseAnchors val = constructObjectPropertyString "anchors" val--data TlsFileDatabaseAnchorsPropertyInfo-instance AttrInfo TlsFileDatabaseAnchorsPropertyInfo where-    type AttrAllowedOps TlsFileDatabaseAnchorsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint TlsFileDatabaseAnchorsPropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint TlsFileDatabaseAnchorsPropertyInfo = TlsFileDatabaseK-    type AttrGetType TlsFileDatabaseAnchorsPropertyInfo = T.Text-    type AttrLabel TlsFileDatabaseAnchorsPropertyInfo = "TlsFileDatabase::anchors"-    attrGet _ = getTlsFileDatabaseAnchors-    attrSet _ = setTlsFileDatabaseAnchors-    attrConstruct _ = constructTlsFileDatabaseAnchors--type instance AttributeList TlsFileDatabase = '[ '("anchors", TlsFileDatabaseAnchorsPropertyInfo)]--type instance AttributeList TlsInteraction = '[ ]---- VVV Prop "description"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable]--getTlsPasswordDescription :: (MonadIO m, TlsPasswordK o) => o -> m T.Text-getTlsPasswordDescription obj = liftIO $ getObjectPropertyString obj "description"--setTlsPasswordDescription :: (MonadIO m, TlsPasswordK o) => o -> T.Text -> m ()-setTlsPasswordDescription obj val = liftIO $ setObjectPropertyString obj "description" val--constructTlsPasswordDescription :: T.Text -> IO ([Char], GValue)-constructTlsPasswordDescription val = constructObjectPropertyString "description" val--data TlsPasswordDescriptionPropertyInfo-instance AttrInfo TlsPasswordDescriptionPropertyInfo where-    type AttrAllowedOps TlsPasswordDescriptionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint TlsPasswordDescriptionPropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint TlsPasswordDescriptionPropertyInfo = TlsPasswordK-    type AttrGetType TlsPasswordDescriptionPropertyInfo = T.Text-    type AttrLabel TlsPasswordDescriptionPropertyInfo = "TlsPassword::description"-    attrGet _ = getTlsPasswordDescription-    attrSet _ = setTlsPasswordDescription-    attrConstruct _ = constructTlsPasswordDescription---- VVV Prop "flags"-   -- Type: TInterface "Gio" "TlsPasswordFlags"-   -- Flags: [PropertyReadable,PropertyWritable]--getTlsPasswordFlags :: (MonadIO m, TlsPasswordK o) => o -> m [TlsPasswordFlags]-getTlsPasswordFlags obj = liftIO $ getObjectPropertyFlags obj "flags"--setTlsPasswordFlags :: (MonadIO m, TlsPasswordK o) => o -> [TlsPasswordFlags] -> m ()-setTlsPasswordFlags obj val = liftIO $ setObjectPropertyFlags obj "flags" val--constructTlsPasswordFlags :: [TlsPasswordFlags] -> IO ([Char], GValue)-constructTlsPasswordFlags val = constructObjectPropertyFlags "flags" val--data TlsPasswordFlagsPropertyInfo-instance AttrInfo TlsPasswordFlagsPropertyInfo where-    type AttrAllowedOps TlsPasswordFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint TlsPasswordFlagsPropertyInfo = (~) [TlsPasswordFlags]-    type AttrBaseTypeConstraint TlsPasswordFlagsPropertyInfo = TlsPasswordK-    type AttrGetType TlsPasswordFlagsPropertyInfo = [TlsPasswordFlags]-    type AttrLabel TlsPasswordFlagsPropertyInfo = "TlsPassword::flags"-    attrGet _ = getTlsPasswordFlags-    attrSet _ = setTlsPasswordFlags-    attrConstruct _ = constructTlsPasswordFlags---- VVV Prop "warning"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable]--getTlsPasswordWarning :: (MonadIO m, TlsPasswordK o) => o -> m T.Text-getTlsPasswordWarning obj = liftIO $ getObjectPropertyString obj "warning"--setTlsPasswordWarning :: (MonadIO m, TlsPasswordK o) => o -> T.Text -> m ()-setTlsPasswordWarning obj val = liftIO $ setObjectPropertyString obj "warning" val--constructTlsPasswordWarning :: T.Text -> IO ([Char], GValue)-constructTlsPasswordWarning val = constructObjectPropertyString "warning" val--data TlsPasswordWarningPropertyInfo-instance AttrInfo TlsPasswordWarningPropertyInfo where-    type AttrAllowedOps TlsPasswordWarningPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint TlsPasswordWarningPropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint TlsPasswordWarningPropertyInfo = TlsPasswordK-    type AttrGetType TlsPasswordWarningPropertyInfo = T.Text-    type AttrLabel TlsPasswordWarningPropertyInfo = "TlsPassword::warning"-    attrGet _ = getTlsPasswordWarning-    attrSet _ = setTlsPasswordWarning-    attrConstruct _ = constructTlsPasswordWarning--type instance AttributeList TlsPassword = '[ '("description", TlsPasswordDescriptionPropertyInfo), '("flags", TlsPasswordFlagsPropertyInfo), '("warning", TlsPasswordWarningPropertyInfo)]---- VVV Prop "authentication-mode"-   -- Type: TInterface "Gio" "TlsAuthenticationMode"-   -- Flags: [PropertyReadable,PropertyWritable]--getTlsServerConnectionAuthenticationMode :: (MonadIO m, TlsServerConnectionK o) => o -> m TlsAuthenticationMode-getTlsServerConnectionAuthenticationMode obj = liftIO $ getObjectPropertyEnum obj "authentication-mode"--setTlsServerConnectionAuthenticationMode :: (MonadIO m, TlsServerConnectionK o) => o -> TlsAuthenticationMode -> m ()-setTlsServerConnectionAuthenticationMode obj val = liftIO $ setObjectPropertyEnum obj "authentication-mode" val--constructTlsServerConnectionAuthenticationMode :: TlsAuthenticationMode -> IO ([Char], GValue)-constructTlsServerConnectionAuthenticationMode val = constructObjectPropertyEnum "authentication-mode" val--data TlsServerConnectionAuthenticationModePropertyInfo-instance AttrInfo TlsServerConnectionAuthenticationModePropertyInfo where-    type AttrAllowedOps TlsServerConnectionAuthenticationModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint TlsServerConnectionAuthenticationModePropertyInfo = (~) TlsAuthenticationMode-    type AttrBaseTypeConstraint TlsServerConnectionAuthenticationModePropertyInfo = TlsServerConnectionK-    type AttrGetType TlsServerConnectionAuthenticationModePropertyInfo = TlsAuthenticationMode-    type AttrLabel TlsServerConnectionAuthenticationModePropertyInfo = "TlsServerConnection::authentication-mode"-    attrGet _ = getTlsServerConnectionAuthenticationMode-    attrSet _ = setTlsServerConnectionAuthenticationMode-    attrConstruct _ = constructTlsServerConnectionAuthenticationMode--type instance AttributeList TlsServerConnection = '[ '("authentication-mode", TlsServerConnectionAuthenticationModePropertyInfo), '("base-io-stream", TlsConnectionBaseIoStreamPropertyInfo), '("certificate", TlsConnectionCertificatePropertyInfo), '("closed", IOStreamClosedPropertyInfo), '("database", TlsConnectionDatabasePropertyInfo), '("input-stream", IOStreamInputStreamPropertyInfo), '("interaction", TlsConnectionInteractionPropertyInfo), '("output-stream", IOStreamOutputStreamPropertyInfo), '("peer-certificate", TlsConnectionPeerCertificatePropertyInfo), '("peer-certificate-errors", TlsConnectionPeerCertificateErrorsPropertyInfo), '("rehandshake-mode", TlsConnectionRehandshakeModePropertyInfo), '("require-close-notify", TlsConnectionRequireCloseNotifyPropertyInfo), '("use-system-certdb", TlsConnectionUseSystemCertdbPropertyInfo)]--type instance AttributeList UnixConnection = '[ '("closed", IOStreamClosedPropertyInfo), '("input-stream", IOStreamInputStreamPropertyInfo), '("output-stream", IOStreamOutputStreamPropertyInfo), '("socket", SocketConnectionSocketPropertyInfo)]---- VVV Prop "credentials"-   -- Type: TInterface "Gio" "Credentials"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getUnixCredentialsMessageCredentials :: (MonadIO m, UnixCredentialsMessageK o) => o -> m Credentials-getUnixCredentialsMessageCredentials obj = liftIO $ getObjectPropertyObject obj "credentials" Credentials--constructUnixCredentialsMessageCredentials :: (CredentialsK a) => a -> IO ([Char], GValue)-constructUnixCredentialsMessageCredentials val = constructObjectPropertyObject "credentials" val--data UnixCredentialsMessageCredentialsPropertyInfo-instance AttrInfo UnixCredentialsMessageCredentialsPropertyInfo where-    type AttrAllowedOps UnixCredentialsMessageCredentialsPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint UnixCredentialsMessageCredentialsPropertyInfo = CredentialsK-    type AttrBaseTypeConstraint UnixCredentialsMessageCredentialsPropertyInfo = UnixCredentialsMessageK-    type AttrGetType UnixCredentialsMessageCredentialsPropertyInfo = Credentials-    type AttrLabel UnixCredentialsMessageCredentialsPropertyInfo = "UnixCredentialsMessage::credentials"-    attrGet _ = getUnixCredentialsMessageCredentials-    attrSet _ = undefined-    attrConstruct _ = constructUnixCredentialsMessageCredentials--type instance AttributeList UnixCredentialsMessage = '[ '("credentials", UnixCredentialsMessageCredentialsPropertyInfo)]--type instance AttributeList UnixFDList = '[ ]---- VVV Prop "fd-list"-   -- Type: TInterface "Gio" "UnixFDList"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getUnixFDMessageFdList :: (MonadIO m, UnixFDMessageK o) => o -> m UnixFDList-getUnixFDMessageFdList obj = liftIO $ getObjectPropertyObject obj "fd-list" UnixFDList--constructUnixFDMessageFdList :: (UnixFDListK a) => a -> IO ([Char], GValue)-constructUnixFDMessageFdList val = constructObjectPropertyObject "fd-list" val--data UnixFDMessageFdListPropertyInfo-instance AttrInfo UnixFDMessageFdListPropertyInfo where-    type AttrAllowedOps UnixFDMessageFdListPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint UnixFDMessageFdListPropertyInfo = UnixFDListK-    type AttrBaseTypeConstraint UnixFDMessageFdListPropertyInfo = UnixFDMessageK-    type AttrGetType UnixFDMessageFdListPropertyInfo = UnixFDList-    type AttrLabel UnixFDMessageFdListPropertyInfo = "UnixFDMessage::fd-list"-    attrGet _ = getUnixFDMessageFdList-    attrSet _ = undefined-    attrConstruct _ = constructUnixFDMessageFdList--type instance AttributeList UnixFDMessage = '[ '("fd-list", UnixFDMessageFdListPropertyInfo)]---- VVV Prop "close-fd"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable,PropertyWritable]--getUnixInputStreamCloseFd :: (MonadIO m, UnixInputStreamK o) => o -> m Bool-getUnixInputStreamCloseFd obj = liftIO $ getObjectPropertyBool obj "close-fd"--setUnixInputStreamCloseFd :: (MonadIO m, UnixInputStreamK o) => o -> Bool -> m ()-setUnixInputStreamCloseFd obj val = liftIO $ setObjectPropertyBool obj "close-fd" val--constructUnixInputStreamCloseFd :: Bool -> IO ([Char], GValue)-constructUnixInputStreamCloseFd val = constructObjectPropertyBool "close-fd" val--data UnixInputStreamCloseFdPropertyInfo-instance AttrInfo UnixInputStreamCloseFdPropertyInfo where-    type AttrAllowedOps UnixInputStreamCloseFdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint UnixInputStreamCloseFdPropertyInfo = (~) Bool-    type AttrBaseTypeConstraint UnixInputStreamCloseFdPropertyInfo = UnixInputStreamK-    type AttrGetType UnixInputStreamCloseFdPropertyInfo = Bool-    type AttrLabel UnixInputStreamCloseFdPropertyInfo = "UnixInputStream::close-fd"-    attrGet _ = getUnixInputStreamCloseFd-    attrSet _ = setUnixInputStreamCloseFd-    attrConstruct _ = constructUnixInputStreamCloseFd---- VVV Prop "fd"-   -- Type: TBasicType TInt32-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getUnixInputStreamFd :: (MonadIO m, UnixInputStreamK o) => o -> m Int32-getUnixInputStreamFd obj = liftIO $ getObjectPropertyCInt obj "fd"--constructUnixInputStreamFd :: Int32 -> IO ([Char], GValue)-constructUnixInputStreamFd val = constructObjectPropertyCInt "fd" val--data UnixInputStreamFdPropertyInfo-instance AttrInfo UnixInputStreamFdPropertyInfo where-    type AttrAllowedOps UnixInputStreamFdPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint UnixInputStreamFdPropertyInfo = (~) Int32-    type AttrBaseTypeConstraint UnixInputStreamFdPropertyInfo = UnixInputStreamK-    type AttrGetType UnixInputStreamFdPropertyInfo = Int32-    type AttrLabel UnixInputStreamFdPropertyInfo = "UnixInputStream::fd"-    attrGet _ = getUnixInputStreamFd-    attrSet _ = undefined-    attrConstruct _ = constructUnixInputStreamFd--type instance AttributeList UnixInputStream = '[ '("close-fd", UnixInputStreamCloseFdPropertyInfo), '("fd", UnixInputStreamFdPropertyInfo)]--type instance AttributeList UnixMountMonitor = '[ ]---- VVV Prop "close-fd"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable,PropertyWritable]--getUnixOutputStreamCloseFd :: (MonadIO m, UnixOutputStreamK o) => o -> m Bool-getUnixOutputStreamCloseFd obj = liftIO $ getObjectPropertyBool obj "close-fd"--setUnixOutputStreamCloseFd :: (MonadIO m, UnixOutputStreamK o) => o -> Bool -> m ()-setUnixOutputStreamCloseFd obj val = liftIO $ setObjectPropertyBool obj "close-fd" val--constructUnixOutputStreamCloseFd :: Bool -> IO ([Char], GValue)-constructUnixOutputStreamCloseFd val = constructObjectPropertyBool "close-fd" val--data UnixOutputStreamCloseFdPropertyInfo-instance AttrInfo UnixOutputStreamCloseFdPropertyInfo where-    type AttrAllowedOps UnixOutputStreamCloseFdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint UnixOutputStreamCloseFdPropertyInfo = (~) Bool-    type AttrBaseTypeConstraint UnixOutputStreamCloseFdPropertyInfo = UnixOutputStreamK-    type AttrGetType UnixOutputStreamCloseFdPropertyInfo = Bool-    type AttrLabel UnixOutputStreamCloseFdPropertyInfo = "UnixOutputStream::close-fd"-    attrGet _ = getUnixOutputStreamCloseFd-    attrSet _ = setUnixOutputStreamCloseFd-    attrConstruct _ = constructUnixOutputStreamCloseFd---- VVV Prop "fd"-   -- Type: TBasicType TInt32-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getUnixOutputStreamFd :: (MonadIO m, UnixOutputStreamK o) => o -> m Int32-getUnixOutputStreamFd obj = liftIO $ getObjectPropertyCInt obj "fd"--constructUnixOutputStreamFd :: Int32 -> IO ([Char], GValue)-constructUnixOutputStreamFd val = constructObjectPropertyCInt "fd" val--data UnixOutputStreamFdPropertyInfo-instance AttrInfo UnixOutputStreamFdPropertyInfo where-    type AttrAllowedOps UnixOutputStreamFdPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint UnixOutputStreamFdPropertyInfo = (~) Int32-    type AttrBaseTypeConstraint UnixOutputStreamFdPropertyInfo = UnixOutputStreamK-    type AttrGetType UnixOutputStreamFdPropertyInfo = Int32-    type AttrLabel UnixOutputStreamFdPropertyInfo = "UnixOutputStream::fd"-    attrGet _ = getUnixOutputStreamFd-    attrSet _ = undefined-    attrConstruct _ = constructUnixOutputStreamFd--type instance AttributeList UnixOutputStream = '[ '("close-fd", UnixOutputStreamCloseFdPropertyInfo), '("fd", UnixOutputStreamFdPropertyInfo)]---- VVV Prop "abstract"-   -- Type: TBasicType TBoolean-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getUnixSocketAddressAbstract :: (MonadIO m, UnixSocketAddressK o) => o -> m Bool-getUnixSocketAddressAbstract obj = liftIO $ getObjectPropertyBool obj "abstract"--constructUnixSocketAddressAbstract :: Bool -> IO ([Char], GValue)-constructUnixSocketAddressAbstract val = constructObjectPropertyBool "abstract" val--data UnixSocketAddressAbstractPropertyInfo-instance AttrInfo UnixSocketAddressAbstractPropertyInfo where-    type AttrAllowedOps UnixSocketAddressAbstractPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint UnixSocketAddressAbstractPropertyInfo = (~) Bool-    type AttrBaseTypeConstraint UnixSocketAddressAbstractPropertyInfo = UnixSocketAddressK-    type AttrGetType UnixSocketAddressAbstractPropertyInfo = Bool-    type AttrLabel UnixSocketAddressAbstractPropertyInfo = "UnixSocketAddress::abstract"-    attrGet _ = getUnixSocketAddressAbstract-    attrSet _ = undefined-    attrConstruct _ = constructUnixSocketAddressAbstract---- VVV Prop "address-type"-   -- Type: TInterface "Gio" "UnixSocketAddressType"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getUnixSocketAddressAddressType :: (MonadIO m, UnixSocketAddressK o) => o -> m UnixSocketAddressType-getUnixSocketAddressAddressType obj = liftIO $ getObjectPropertyEnum obj "address-type"--constructUnixSocketAddressAddressType :: UnixSocketAddressType -> IO ([Char], GValue)-constructUnixSocketAddressAddressType val = constructObjectPropertyEnum "address-type" val--data UnixSocketAddressAddressTypePropertyInfo-instance AttrInfo UnixSocketAddressAddressTypePropertyInfo where-    type AttrAllowedOps UnixSocketAddressAddressTypePropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint UnixSocketAddressAddressTypePropertyInfo = (~) UnixSocketAddressType-    type AttrBaseTypeConstraint UnixSocketAddressAddressTypePropertyInfo = UnixSocketAddressK-    type AttrGetType UnixSocketAddressAddressTypePropertyInfo = UnixSocketAddressType-    type AttrLabel UnixSocketAddressAddressTypePropertyInfo = "UnixSocketAddress::address-type"-    attrGet _ = getUnixSocketAddressAddressType-    attrSet _ = undefined-    attrConstruct _ = constructUnixSocketAddressAddressType---- VVV Prop "path"-   -- Type: TBasicType TUTF8-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getUnixSocketAddressPath :: (MonadIO m, UnixSocketAddressK o) => o -> m T.Text-getUnixSocketAddressPath obj = liftIO $ getObjectPropertyString obj "path"--constructUnixSocketAddressPath :: T.Text -> IO ([Char], GValue)-constructUnixSocketAddressPath val = constructObjectPropertyString "path" val--data UnixSocketAddressPathPropertyInfo-instance AttrInfo UnixSocketAddressPathPropertyInfo where-    type AttrAllowedOps UnixSocketAddressPathPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint UnixSocketAddressPathPropertyInfo = (~) T.Text-    type AttrBaseTypeConstraint UnixSocketAddressPathPropertyInfo = UnixSocketAddressK-    type AttrGetType UnixSocketAddressPathPropertyInfo = T.Text-    type AttrLabel UnixSocketAddressPathPropertyInfo = "UnixSocketAddress::path"-    attrGet _ = getUnixSocketAddressPath-    attrSet _ = undefined-    attrConstruct _ = constructUnixSocketAddressPath---- VVV Prop "path-as-array"-   -- Type: TByteArray-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getUnixSocketAddressPathAsArray :: (MonadIO m, UnixSocketAddressK o) => o -> m ByteString-getUnixSocketAddressPathAsArray obj = liftIO $ getObjectPropertyByteArray obj "path-as-array"--constructUnixSocketAddressPathAsArray :: ByteString -> IO ([Char], GValue)-constructUnixSocketAddressPathAsArray val = constructObjectPropertyByteArray "path-as-array" val--data UnixSocketAddressPathAsArrayPropertyInfo-instance AttrInfo UnixSocketAddressPathAsArrayPropertyInfo where-    type AttrAllowedOps UnixSocketAddressPathAsArrayPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint UnixSocketAddressPathAsArrayPropertyInfo = (~) ByteString-    type AttrBaseTypeConstraint UnixSocketAddressPathAsArrayPropertyInfo = UnixSocketAddressK-    type AttrGetType UnixSocketAddressPathAsArrayPropertyInfo = ByteString-    type AttrLabel UnixSocketAddressPathAsArrayPropertyInfo = "UnixSocketAddress::path-as-array"-    attrGet _ = getUnixSocketAddressPathAsArray-    attrSet _ = undefined-    attrConstruct _ = constructUnixSocketAddressPathAsArray--type instance AttributeList UnixSocketAddress = '[ '("abstract", UnixSocketAddressAbstractPropertyInfo), '("address-type", UnixSocketAddressAddressTypePropertyInfo), '("family", SocketAddressFamilyPropertyInfo), '("path", UnixSocketAddressPathPropertyInfo), '("path-as-array", UnixSocketAddressPathAsArrayPropertyInfo)]--type instance AttributeList Vfs = '[ ]--type instance AttributeList Volume = '[ ]--type instance AttributeList VolumeMonitor = '[ ]---- VVV Prop "file-info"-   -- Type: TInterface "Gio" "FileInfo"-   -- Flags: [PropertyReadable,PropertyWritable]--getZlibCompressorFileInfo :: (MonadIO m, ZlibCompressorK o) => o -> m FileInfo-getZlibCompressorFileInfo obj = liftIO $ getObjectPropertyObject obj "file-info" FileInfo--setZlibCompressorFileInfo :: (MonadIO m, ZlibCompressorK o, FileInfoK a) => o -> a -> m ()-setZlibCompressorFileInfo obj val = liftIO $ setObjectPropertyObject obj "file-info" val--constructZlibCompressorFileInfo :: (FileInfoK a) => a -> IO ([Char], GValue)-constructZlibCompressorFileInfo val = constructObjectPropertyObject "file-info" val--data ZlibCompressorFileInfoPropertyInfo-instance AttrInfo ZlibCompressorFileInfoPropertyInfo where-    type AttrAllowedOps ZlibCompressorFileInfoPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint ZlibCompressorFileInfoPropertyInfo = FileInfoK-    type AttrBaseTypeConstraint ZlibCompressorFileInfoPropertyInfo = ZlibCompressorK-    type AttrGetType ZlibCompressorFileInfoPropertyInfo = FileInfo-    type AttrLabel ZlibCompressorFileInfoPropertyInfo = "ZlibCompressor::file-info"-    attrGet _ = getZlibCompressorFileInfo-    attrSet _ = setZlibCompressorFileInfo-    attrConstruct _ = constructZlibCompressorFileInfo---- VVV Prop "format"-   -- Type: TInterface "Gio" "ZlibCompressorFormat"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getZlibCompressorFormat :: (MonadIO m, ZlibCompressorK o) => o -> m ZlibCompressorFormat-getZlibCompressorFormat obj = liftIO $ getObjectPropertyEnum obj "format"--constructZlibCompressorFormat :: ZlibCompressorFormat -> IO ([Char], GValue)-constructZlibCompressorFormat val = constructObjectPropertyEnum "format" val--data ZlibCompressorFormatPropertyInfo-instance AttrInfo ZlibCompressorFormatPropertyInfo where-    type AttrAllowedOps ZlibCompressorFormatPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint ZlibCompressorFormatPropertyInfo = (~) ZlibCompressorFormat-    type AttrBaseTypeConstraint ZlibCompressorFormatPropertyInfo = ZlibCompressorK-    type AttrGetType ZlibCompressorFormatPropertyInfo = ZlibCompressorFormat-    type AttrLabel ZlibCompressorFormatPropertyInfo = "ZlibCompressor::format"-    attrGet _ = getZlibCompressorFormat-    attrSet _ = undefined-    attrConstruct _ = constructZlibCompressorFormat---- VVV Prop "level"-   -- Type: TBasicType TInt32-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getZlibCompressorLevel :: (MonadIO m, ZlibCompressorK o) => o -> m Int32-getZlibCompressorLevel obj = liftIO $ getObjectPropertyCInt obj "level"--constructZlibCompressorLevel :: Int32 -> IO ([Char], GValue)-constructZlibCompressorLevel val = constructObjectPropertyCInt "level" val--data ZlibCompressorLevelPropertyInfo-instance AttrInfo ZlibCompressorLevelPropertyInfo where-    type AttrAllowedOps ZlibCompressorLevelPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint ZlibCompressorLevelPropertyInfo = (~) Int32-    type AttrBaseTypeConstraint ZlibCompressorLevelPropertyInfo = ZlibCompressorK-    type AttrGetType ZlibCompressorLevelPropertyInfo = Int32-    type AttrLabel ZlibCompressorLevelPropertyInfo = "ZlibCompressor::level"-    attrGet _ = getZlibCompressorLevel-    attrSet _ = undefined-    attrConstruct _ = constructZlibCompressorLevel--type instance AttributeList ZlibCompressor = '[ '("file-info", ZlibCompressorFileInfoPropertyInfo), '("format", ZlibCompressorFormatPropertyInfo), '("level", ZlibCompressorLevelPropertyInfo)]---- VVV Prop "file-info"-   -- Type: TInterface "Gio" "FileInfo"-   -- Flags: [PropertyReadable]--getZlibDecompressorFileInfo :: (MonadIO m, ZlibDecompressorK o) => o -> m FileInfo-getZlibDecompressorFileInfo obj = liftIO $ getObjectPropertyObject obj "file-info" FileInfo--data ZlibDecompressorFileInfoPropertyInfo-instance AttrInfo ZlibDecompressorFileInfoPropertyInfo where-    type AttrAllowedOps ZlibDecompressorFileInfoPropertyInfo = '[ 'AttrGet]-    type AttrSetTypeConstraint ZlibDecompressorFileInfoPropertyInfo = (~) ()-    type AttrBaseTypeConstraint ZlibDecompressorFileInfoPropertyInfo = ZlibDecompressorK-    type AttrGetType ZlibDecompressorFileInfoPropertyInfo = FileInfo-    type AttrLabel ZlibDecompressorFileInfoPropertyInfo = "ZlibDecompressor::file-info"-    attrGet _ = getZlibDecompressorFileInfo-    attrSet _ = undefined-    attrConstruct _ = undefined---- VVV Prop "format"-   -- Type: TInterface "Gio" "ZlibCompressorFormat"-   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]--getZlibDecompressorFormat :: (MonadIO m, ZlibDecompressorK o) => o -> m ZlibCompressorFormat-getZlibDecompressorFormat obj = liftIO $ getObjectPropertyEnum obj "format"--constructZlibDecompressorFormat :: ZlibCompressorFormat -> IO ([Char], GValue)-constructZlibDecompressorFormat val = constructObjectPropertyEnum "format" val--data ZlibDecompressorFormatPropertyInfo-instance AttrInfo ZlibDecompressorFormatPropertyInfo where-    type AttrAllowedOps ZlibDecompressorFormatPropertyInfo = '[ 'AttrConstruct, 'AttrGet]-    type AttrSetTypeConstraint ZlibDecompressorFormatPropertyInfo = (~) ZlibCompressorFormat-    type AttrBaseTypeConstraint ZlibDecompressorFormatPropertyInfo = ZlibDecompressorK-    type AttrGetType ZlibDecompressorFormatPropertyInfo = ZlibCompressorFormat-    type AttrLabel ZlibDecompressorFormatPropertyInfo = "ZlibDecompressor::format"-    attrGet _ = getZlibDecompressorFormat-    attrSet _ = undefined-    attrConstruct _ = constructZlibDecompressorFormat--type instance AttributeList ZlibDecompressor = '[ '("file-info", ZlibDecompressorFileInfoPropertyInfo), '("format", ZlibDecompressorFormatPropertyInfo)]-
− GI/GioSignals.hs 
@@ -1,669 +0,0 @@--- Generated code.--{-# OPTIONS_GHC -fno-warn-orphans #-}--{-# LANGUAGE DataKinds,    FlexibleInstances,-             TypeFamilies, MultiParamTypeClasses,-               TypeOperators #-}--module GI.GioSignals where--import Data.GI.Base.Properties (GObjectNotifySignalInfo)-import Data.GI.Base.Signals-import Data.GI.Base.Overloading--import qualified GI.GObjectSignals as GObject-import GI.Gio--type instance SignalList Action = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--data ActionGroupActionAddedSignalInfo-instance SignalInfo ActionGroupActionAddedSignalInfo where-    type HaskellCallbackType ActionGroupActionAddedSignalInfo = ActionGroupActionAddedCallback-    connectSignal _ = connectActionGroupActionAdded--data ActionGroupActionEnabledChangedSignalInfo-instance SignalInfo ActionGroupActionEnabledChangedSignalInfo where-    type HaskellCallbackType ActionGroupActionEnabledChangedSignalInfo = ActionGroupActionEnabledChangedCallback-    connectSignal _ = connectActionGroupActionEnabledChanged--data ActionGroupActionRemovedSignalInfo-instance SignalInfo ActionGroupActionRemovedSignalInfo where-    type HaskellCallbackType ActionGroupActionRemovedSignalInfo = ActionGroupActionRemovedCallback-    connectSignal _ = connectActionGroupActionRemoved--data ActionGroupActionStateChangedSignalInfo-instance SignalInfo ActionGroupActionStateChangedSignalInfo where-    type HaskellCallbackType ActionGroupActionStateChangedSignalInfo = ActionGroupActionStateChangedCallback-    connectSignal _ = connectActionGroupActionStateChanged--type instance SignalList ActionGroup = '[ '("action-added", ActionGroupActionAddedSignalInfo), '("action-enabled-changed", ActionGroupActionEnabledChangedSignalInfo), '("action-removed", ActionGroupActionRemovedSignalInfo), '("action-state-changed", ActionGroupActionStateChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList ActionMap = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList AppInfo = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--data AppInfoMonitorChangedSignalInfo-instance SignalInfo AppInfoMonitorChangedSignalInfo where-    type HaskellCallbackType AppInfoMonitorChangedSignalInfo = AppInfoMonitorChangedCallback-    connectSignal _ = connectAppInfoMonitorChanged--type instance SignalList AppInfoMonitor = '[ '("changed", AppInfoMonitorChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--data AppLaunchContextLaunchFailedSignalInfo-instance SignalInfo AppLaunchContextLaunchFailedSignalInfo where-    type HaskellCallbackType AppLaunchContextLaunchFailedSignalInfo = AppLaunchContextLaunchFailedCallback-    connectSignal _ = connectAppLaunchContextLaunchFailed--data AppLaunchContextLaunchedSignalInfo-instance SignalInfo AppLaunchContextLaunchedSignalInfo where-    type HaskellCallbackType AppLaunchContextLaunchedSignalInfo = AppLaunchContextLaunchedCallback-    connectSignal _ = connectAppLaunchContextLaunched--type instance SignalList AppLaunchContext = '[ '("launch-failed", AppLaunchContextLaunchFailedSignalInfo), '("launched", AppLaunchContextLaunchedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--data ApplicationActivateSignalInfo-instance SignalInfo ApplicationActivateSignalInfo where-    type HaskellCallbackType ApplicationActivateSignalInfo = ApplicationActivateCallback-    connectSignal _ = connectApplicationActivate--data ApplicationCommandLineSignalInfo-instance SignalInfo ApplicationCommandLineSignalInfo where-    type HaskellCallbackType ApplicationCommandLineSignalInfo = ApplicationCommandLineCallback-    connectSignal _ = connectApplicationCommandLine--data ApplicationHandleLocalOptionsSignalInfo-instance SignalInfo ApplicationHandleLocalOptionsSignalInfo where-    type HaskellCallbackType ApplicationHandleLocalOptionsSignalInfo = ApplicationHandleLocalOptionsCallback-    connectSignal _ = connectApplicationHandleLocalOptions--data ApplicationOpenSignalInfo-instance SignalInfo ApplicationOpenSignalInfo where-    type HaskellCallbackType ApplicationOpenSignalInfo = ApplicationOpenCallback-    connectSignal _ = connectApplicationOpen--data ApplicationShutdownSignalInfo-instance SignalInfo ApplicationShutdownSignalInfo where-    type HaskellCallbackType ApplicationShutdownSignalInfo = ApplicationShutdownCallback-    connectSignal _ = connectApplicationShutdown--data ApplicationStartupSignalInfo-instance SignalInfo ApplicationStartupSignalInfo where-    type HaskellCallbackType ApplicationStartupSignalInfo = ApplicationStartupCallback-    connectSignal _ = connectApplicationStartup--type instance SignalList Application = '[ '("action-added", ActionGroupActionAddedSignalInfo), '("action-enabled-changed", ActionGroupActionEnabledChangedSignalInfo), '("action-removed", ActionGroupActionRemovedSignalInfo), '("action-state-changed", ActionGroupActionStateChangedSignalInfo), '("activate", ApplicationActivateSignalInfo), '("command-line", ApplicationCommandLineSignalInfo), '("handle-local-options", ApplicationHandleLocalOptionsSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("open", ApplicationOpenSignalInfo), '("shutdown", ApplicationShutdownSignalInfo), '("startup", ApplicationStartupSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList ApplicationCommandLine = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList AsyncInitable = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList AsyncResult = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList BufferedInputStream = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList BufferedOutputStream = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList BytesIcon = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--data CancellableCancelledSignalInfo-instance SignalInfo CancellableCancelledSignalInfo where-    type HaskellCallbackType CancellableCancelledSignalInfo = CancellableCancelledCallback-    connectSignal _ = connectCancellableCancelled--type instance SignalList Cancellable = '[ '("cancelled", CancellableCancelledSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList CharsetConverter = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList Converter = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList ConverterInputStream = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList ConverterOutputStream = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList Credentials = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList DBusActionGroup = '[ '("action-added", ActionGroupActionAddedSignalInfo), '("action-enabled-changed", ActionGroupActionEnabledChangedSignalInfo), '("action-removed", ActionGroupActionRemovedSignalInfo), '("action-state-changed", ActionGroupActionStateChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--data DBusAuthObserverAllowMechanismSignalInfo-instance SignalInfo DBusAuthObserverAllowMechanismSignalInfo where-    type HaskellCallbackType DBusAuthObserverAllowMechanismSignalInfo = DBusAuthObserverAllowMechanismCallback-    connectSignal _ = connectDBusAuthObserverAllowMechanism--data DBusAuthObserverAuthorizeAuthenticatedPeerSignalInfo-instance SignalInfo DBusAuthObserverAuthorizeAuthenticatedPeerSignalInfo where-    type HaskellCallbackType DBusAuthObserverAuthorizeAuthenticatedPeerSignalInfo = DBusAuthObserverAuthorizeAuthenticatedPeerCallback-    connectSignal _ = connectDBusAuthObserverAuthorizeAuthenticatedPeer--type instance SignalList DBusAuthObserver = '[ '("allow-mechanism", DBusAuthObserverAllowMechanismSignalInfo), '("authorize-authenticated-peer", DBusAuthObserverAuthorizeAuthenticatedPeerSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--data DBusConnectionClosedSignalInfo-instance SignalInfo DBusConnectionClosedSignalInfo where-    type HaskellCallbackType DBusConnectionClosedSignalInfo = DBusConnectionClosedCallback-    connectSignal _ = connectDBusConnectionClosed--type instance SignalList DBusConnection = '[ '("closed", DBusConnectionClosedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList DBusInterface = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--data DBusInterfaceSkeletonGAuthorizeMethodSignalInfo-instance SignalInfo DBusInterfaceSkeletonGAuthorizeMethodSignalInfo where-    type HaskellCallbackType DBusInterfaceSkeletonGAuthorizeMethodSignalInfo = DBusInterfaceSkeletonGAuthorizeMethodCallback-    connectSignal _ = connectDBusInterfaceSkeletonGAuthorizeMethod--type instance SignalList DBusInterfaceSkeleton = '[ '("g-authorize-method", DBusInterfaceSkeletonGAuthorizeMethodSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList DBusMenuModel = '[ '("items-changed", MenuModelItemsChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList DBusMessage = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList DBusMethodInvocation = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--data DBusObjectInterfaceAddedSignalInfo-instance SignalInfo DBusObjectInterfaceAddedSignalInfo where-    type HaskellCallbackType DBusObjectInterfaceAddedSignalInfo = DBusObjectInterfaceAddedCallback-    connectSignal _ = connectDBusObjectInterfaceAdded--data DBusObjectInterfaceRemovedSignalInfo-instance SignalInfo DBusObjectInterfaceRemovedSignalInfo where-    type HaskellCallbackType DBusObjectInterfaceRemovedSignalInfo = DBusObjectInterfaceRemovedCallback-    connectSignal _ = connectDBusObjectInterfaceRemoved--type instance SignalList DBusObject = '[ '("interface-added", DBusObjectInterfaceAddedSignalInfo), '("interface-removed", DBusObjectInterfaceRemovedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--data DBusObjectManagerInterfaceAddedSignalInfo-instance SignalInfo DBusObjectManagerInterfaceAddedSignalInfo where-    type HaskellCallbackType DBusObjectManagerInterfaceAddedSignalInfo = DBusObjectManagerInterfaceAddedCallback-    connectSignal _ = connectDBusObjectManagerInterfaceAdded--data DBusObjectManagerInterfaceRemovedSignalInfo-instance SignalInfo DBusObjectManagerInterfaceRemovedSignalInfo where-    type HaskellCallbackType DBusObjectManagerInterfaceRemovedSignalInfo = DBusObjectManagerInterfaceRemovedCallback-    connectSignal _ = connectDBusObjectManagerInterfaceRemoved--data DBusObjectManagerObjectAddedSignalInfo-instance SignalInfo DBusObjectManagerObjectAddedSignalInfo where-    type HaskellCallbackType DBusObjectManagerObjectAddedSignalInfo = DBusObjectManagerObjectAddedCallback-    connectSignal _ = connectDBusObjectManagerObjectAdded--data DBusObjectManagerObjectRemovedSignalInfo-instance SignalInfo DBusObjectManagerObjectRemovedSignalInfo where-    type HaskellCallbackType DBusObjectManagerObjectRemovedSignalInfo = DBusObjectManagerObjectRemovedCallback-    connectSignal _ = connectDBusObjectManagerObjectRemoved--type instance SignalList DBusObjectManager = '[ '("interface-added", DBusObjectManagerInterfaceAddedSignalInfo), '("interface-removed", DBusObjectManagerInterfaceRemovedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("object-added", DBusObjectManagerObjectAddedSignalInfo), '("object-removed", DBusObjectManagerObjectRemovedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--data DBusObjectManagerClientInterfaceProxyPropertiesChangedSignalInfo-instance SignalInfo DBusObjectManagerClientInterfaceProxyPropertiesChangedSignalInfo where-    type HaskellCallbackType DBusObjectManagerClientInterfaceProxyPropertiesChangedSignalInfo = DBusObjectManagerClientInterfaceProxyPropertiesChangedCallback-    connectSignal _ = connectDBusObjectManagerClientInterfaceProxyPropertiesChanged--data DBusObjectManagerClientInterfaceProxySignalSignalInfo-instance SignalInfo DBusObjectManagerClientInterfaceProxySignalSignalInfo where-    type HaskellCallbackType DBusObjectManagerClientInterfaceProxySignalSignalInfo = DBusObjectManagerClientInterfaceProxySignalCallback-    connectSignal _ = connectDBusObjectManagerClientInterfaceProxySignal--type instance SignalList DBusObjectManagerClient = '[ '("interface-added", DBusObjectManagerInterfaceAddedSignalInfo), '("interface-proxy-properties-changed", DBusObjectManagerClientInterfaceProxyPropertiesChangedSignalInfo), '("interface-proxy-signal", DBusObjectManagerClientInterfaceProxySignalSignalInfo), '("interface-removed", DBusObjectManagerInterfaceRemovedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("object-added", DBusObjectManagerObjectAddedSignalInfo), '("object-removed", DBusObjectManagerObjectRemovedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList DBusObjectManagerServer = '[ '("interface-added", DBusObjectManagerInterfaceAddedSignalInfo), '("interface-removed", DBusObjectManagerInterfaceRemovedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("object-added", DBusObjectManagerObjectAddedSignalInfo), '("object-removed", DBusObjectManagerObjectRemovedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList DBusObjectProxy = '[ '("interface-added", DBusObjectInterfaceAddedSignalInfo), '("interface-removed", DBusObjectInterfaceRemovedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--data DBusObjectSkeletonAuthorizeMethodSignalInfo-instance SignalInfo DBusObjectSkeletonAuthorizeMethodSignalInfo where-    type HaskellCallbackType DBusObjectSkeletonAuthorizeMethodSignalInfo = DBusObjectSkeletonAuthorizeMethodCallback-    connectSignal _ = connectDBusObjectSkeletonAuthorizeMethod--type instance SignalList DBusObjectSkeleton = '[ '("authorize-method", DBusObjectSkeletonAuthorizeMethodSignalInfo), '("interface-added", DBusObjectInterfaceAddedSignalInfo), '("interface-removed", DBusObjectInterfaceRemovedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--data DBusProxyGPropertiesChangedSignalInfo-instance SignalInfo DBusProxyGPropertiesChangedSignalInfo where-    type HaskellCallbackType DBusProxyGPropertiesChangedSignalInfo = DBusProxyGPropertiesChangedCallback-    connectSignal _ = connectDBusProxyGPropertiesChanged--data DBusProxyGSignalSignalInfo-instance SignalInfo DBusProxyGSignalSignalInfo where-    type HaskellCallbackType DBusProxyGSignalSignalInfo = DBusProxyGSignalCallback-    connectSignal _ = connectDBusProxyGSignal--type instance SignalList DBusProxy = '[ '("g-properties-changed", DBusProxyGPropertiesChangedSignalInfo), '("g-signal", DBusProxyGSignalSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--data DBusServerNewConnectionSignalInfo-instance SignalInfo DBusServerNewConnectionSignalInfo where-    type HaskellCallbackType DBusServerNewConnectionSignalInfo = DBusServerNewConnectionCallback-    connectSignal _ = connectDBusServerNewConnection--type instance SignalList DBusServer = '[ '("new-connection", DBusServerNewConnectionSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList DataInputStream = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList DataOutputStream = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList DesktopAppInfo = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList DesktopAppInfoLookup = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--data DriveChangedSignalInfo-instance SignalInfo DriveChangedSignalInfo where-    type HaskellCallbackType DriveChangedSignalInfo = DriveChangedCallback-    connectSignal _ = connectDriveChanged--data DriveDisconnectedSignalInfo-instance SignalInfo DriveDisconnectedSignalInfo where-    type HaskellCallbackType DriveDisconnectedSignalInfo = DriveDisconnectedCallback-    connectSignal _ = connectDriveDisconnected--data DriveEjectButtonSignalInfo-instance SignalInfo DriveEjectButtonSignalInfo where-    type HaskellCallbackType DriveEjectButtonSignalInfo = DriveEjectButtonCallback-    connectSignal _ = connectDriveEjectButton--data DriveStopButtonSignalInfo-instance SignalInfo DriveStopButtonSignalInfo where-    type HaskellCallbackType DriveStopButtonSignalInfo = DriveStopButtonCallback-    connectSignal _ = connectDriveStopButton--type instance SignalList Drive = '[ '("changed", DriveChangedSignalInfo), '("disconnected", DriveDisconnectedSignalInfo), '("eject-button", DriveEjectButtonSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("stop-button", DriveStopButtonSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList Emblem = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList EmblemedIcon = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList File = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList FileDescriptorBased = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList FileEnumerator = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList FileIOStream = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList FileIcon = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList FileInfo = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList FileInputStream = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--data FileMonitorChangedSignalInfo-instance SignalInfo FileMonitorChangedSignalInfo where-    type HaskellCallbackType FileMonitorChangedSignalInfo = FileMonitorChangedCallback-    connectSignal _ = connectFileMonitorChanged--type instance SignalList FileMonitor = '[ '("changed", FileMonitorChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList FileOutputStream = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--data FilenameCompleterGotCompletionDataSignalInfo-instance SignalInfo FilenameCompleterGotCompletionDataSignalInfo where-    type HaskellCallbackType FilenameCompleterGotCompletionDataSignalInfo = FilenameCompleterGotCompletionDataCallback-    connectSignal _ = connectFilenameCompleterGotCompletionData--type instance SignalList FilenameCompleter = '[ '("got-completion-data", FilenameCompleterGotCompletionDataSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList FilterInputStream = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList FilterOutputStream = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList IOStream = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList Icon = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList InetAddress = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList InetAddressMask = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList InetSocketAddress = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList Initable = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList InputStream = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--data ListModelItemsChangedSignalInfo-instance SignalInfo ListModelItemsChangedSignalInfo where-    type HaskellCallbackType ListModelItemsChangedSignalInfo = ListModelItemsChangedCallback-    connectSignal _ = connectListModelItemsChanged--type instance SignalList ListModel = '[ '("items-changed", ListModelItemsChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList ListStore = '[ '("items-changed", ListModelItemsChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList LoadableIcon = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList MemoryInputStream = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList MemoryOutputStream = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList Menu = '[ '("items-changed", MenuModelItemsChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList MenuAttributeIter = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList MenuItem = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList MenuLinkIter = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--data MenuModelItemsChangedSignalInfo-instance SignalInfo MenuModelItemsChangedSignalInfo where-    type HaskellCallbackType MenuModelItemsChangedSignalInfo = MenuModelItemsChangedCallback-    connectSignal _ = connectMenuModelItemsChanged--type instance SignalList MenuModel = '[ '("items-changed", MenuModelItemsChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--data MountChangedSignalInfo-instance SignalInfo MountChangedSignalInfo where-    type HaskellCallbackType MountChangedSignalInfo = MountChangedCallback-    connectSignal _ = connectMountChanged--data MountPreUnmountSignalInfo-instance SignalInfo MountPreUnmountSignalInfo where-    type HaskellCallbackType MountPreUnmountSignalInfo = MountPreUnmountCallback-    connectSignal _ = connectMountPreUnmount--data MountUnmountedSignalInfo-instance SignalInfo MountUnmountedSignalInfo where-    type HaskellCallbackType MountUnmountedSignalInfo = MountUnmountedCallback-    connectSignal _ = connectMountUnmounted--type instance SignalList Mount = '[ '("changed", MountChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("pre-unmount", MountPreUnmountSignalInfo), '("unmounted", MountUnmountedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--data MountOperationAbortedSignalInfo-instance SignalInfo MountOperationAbortedSignalInfo where-    type HaskellCallbackType MountOperationAbortedSignalInfo = MountOperationAbortedCallback-    connectSignal _ = connectMountOperationAborted--data MountOperationAskPasswordSignalInfo-instance SignalInfo MountOperationAskPasswordSignalInfo where-    type HaskellCallbackType MountOperationAskPasswordSignalInfo = MountOperationAskPasswordCallback-    connectSignal _ = connectMountOperationAskPassword--data MountOperationAskQuestionSignalInfo-instance SignalInfo MountOperationAskQuestionSignalInfo where-    type HaskellCallbackType MountOperationAskQuestionSignalInfo = MountOperationAskQuestionCallback-    connectSignal _ = connectMountOperationAskQuestion--data MountOperationReplySignalInfo-instance SignalInfo MountOperationReplySignalInfo where-    type HaskellCallbackType MountOperationReplySignalInfo = MountOperationReplyCallback-    connectSignal _ = connectMountOperationReply--data MountOperationShowProcessesSignalInfo-instance SignalInfo MountOperationShowProcessesSignalInfo where-    type HaskellCallbackType MountOperationShowProcessesSignalInfo = MountOperationShowProcessesCallback-    connectSignal _ = connectMountOperationShowProcesses--data MountOperationShowUnmountProgressSignalInfo-instance SignalInfo MountOperationShowUnmountProgressSignalInfo where-    type HaskellCallbackType MountOperationShowUnmountProgressSignalInfo = MountOperationShowUnmountProgressCallback-    connectSignal _ = connectMountOperationShowUnmountProgress--type instance SignalList MountOperation = '[ '("aborted", MountOperationAbortedSignalInfo), '("ask-password", MountOperationAskPasswordSignalInfo), '("ask-question", MountOperationAskQuestionSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("reply", MountOperationReplySignalInfo), '("show-processes", MountOperationShowProcessesSignalInfo), '("show-unmount-progress", MountOperationShowUnmountProgressSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList NativeVolumeMonitor = '[ '("drive-changed", VolumeMonitorDriveChangedSignalInfo), '("drive-connected", VolumeMonitorDriveConnectedSignalInfo), '("drive-disconnected", VolumeMonitorDriveDisconnectedSignalInfo), '("drive-eject-button", VolumeMonitorDriveEjectButtonSignalInfo), '("drive-stop-button", VolumeMonitorDriveStopButtonSignalInfo), '("mount-added", VolumeMonitorMountAddedSignalInfo), '("mount-changed", VolumeMonitorMountChangedSignalInfo), '("mount-pre-unmount", VolumeMonitorMountPreUnmountSignalInfo), '("mount-removed", VolumeMonitorMountRemovedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("volume-added", VolumeMonitorVolumeAddedSignalInfo), '("volume-changed", VolumeMonitorVolumeChangedSignalInfo), '("volume-removed", VolumeMonitorVolumeRemovedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList NetworkAddress = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--data NetworkMonitorNetworkChangedSignalInfo-instance SignalInfo NetworkMonitorNetworkChangedSignalInfo where-    type HaskellCallbackType NetworkMonitorNetworkChangedSignalInfo = NetworkMonitorNetworkChangedCallback-    connectSignal _ = connectNetworkMonitorNetworkChanged--type instance SignalList NetworkMonitor = '[ '("network-changed", NetworkMonitorNetworkChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList NetworkService = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList Notification = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList OutputStream = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList Permission = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList PollableInputStream = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList PollableOutputStream = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList PropertyAction = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList Proxy = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList ProxyAddress = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList ProxyAddressEnumerator = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList ProxyResolver = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList RemoteActionGroup = '[ '("action-added", ActionGroupActionAddedSignalInfo), '("action-enabled-changed", ActionGroupActionEnabledChangedSignalInfo), '("action-removed", ActionGroupActionRemovedSignalInfo), '("action-state-changed", ActionGroupActionStateChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--data ResolverReloadSignalInfo-instance SignalInfo ResolverReloadSignalInfo where-    type HaskellCallbackType ResolverReloadSignalInfo = ResolverReloadCallback-    connectSignal _ = connectResolverReload--type instance SignalList Resolver = '[ '("notify", GObject.ObjectNotifySignalInfo), '("reload", ResolverReloadSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList Seekable = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--data SettingsChangeEventSignalInfo-instance SignalInfo SettingsChangeEventSignalInfo where-    type HaskellCallbackType SettingsChangeEventSignalInfo = SettingsChangeEventCallback-    connectSignal _ = connectSettingsChangeEvent--data SettingsChangedSignalInfo-instance SignalInfo SettingsChangedSignalInfo where-    type HaskellCallbackType SettingsChangedSignalInfo = SettingsChangedCallback-    connectSignal _ = connectSettingsChanged--data SettingsWritableChangeEventSignalInfo-instance SignalInfo SettingsWritableChangeEventSignalInfo where-    type HaskellCallbackType SettingsWritableChangeEventSignalInfo = SettingsWritableChangeEventCallback-    connectSignal _ = connectSettingsWritableChangeEvent--data SettingsWritableChangedSignalInfo-instance SignalInfo SettingsWritableChangedSignalInfo where-    type HaskellCallbackType SettingsWritableChangedSignalInfo = SettingsWritableChangedCallback-    connectSignal _ = connectSettingsWritableChanged--type instance SignalList Settings = '[ '("change-event", SettingsChangeEventSignalInfo), '("changed", SettingsChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("writable-change-event", SettingsWritableChangeEventSignalInfo), '("writable-changed", SettingsWritableChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--data SimpleActionActivateSignalInfo-instance SignalInfo SimpleActionActivateSignalInfo where-    type HaskellCallbackType SimpleActionActivateSignalInfo = SimpleActionActivateCallback-    connectSignal _ = connectSimpleActionActivate--data SimpleActionChangeStateSignalInfo-instance SignalInfo SimpleActionChangeStateSignalInfo where-    type HaskellCallbackType SimpleActionChangeStateSignalInfo = SimpleActionChangeStateCallback-    connectSignal _ = connectSimpleActionChangeState--type instance SignalList SimpleAction = '[ '("activate", SimpleActionActivateSignalInfo), '("change-state", SimpleActionChangeStateSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList SimpleActionGroup = '[ '("action-added", ActionGroupActionAddedSignalInfo), '("action-enabled-changed", ActionGroupActionEnabledChangedSignalInfo), '("action-removed", ActionGroupActionRemovedSignalInfo), '("action-state-changed", ActionGroupActionStateChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList SimpleAsyncResult = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList SimpleIOStream = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList SimplePermission = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList SimpleProxyResolver = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList Socket = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList SocketAddress = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList SocketAddressEnumerator = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--data SocketClientEventSignalInfo-instance SignalInfo SocketClientEventSignalInfo where-    type HaskellCallbackType SocketClientEventSignalInfo = SocketClientEventCallback-    connectSignal _ = connectSocketClientEvent--type instance SignalList SocketClient = '[ '("event", SocketClientEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList SocketConnectable = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList SocketConnection = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList SocketControlMessage = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--data SocketListenerEventSignalInfo-instance SignalInfo SocketListenerEventSignalInfo where-    type HaskellCallbackType SocketListenerEventSignalInfo = SocketListenerEventCallback-    connectSignal _ = connectSocketListenerEvent--type instance SignalList SocketListener = '[ '("event", SocketListenerEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--data SocketServiceIncomingSignalInfo-instance SignalInfo SocketServiceIncomingSignalInfo where-    type HaskellCallbackType SocketServiceIncomingSignalInfo = SocketServiceIncomingCallback-    connectSignal _ = connectSocketServiceIncoming--type instance SignalList SocketService = '[ '("event", SocketListenerEventSignalInfo), '("incoming", SocketServiceIncomingSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList Subprocess = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList SubprocessLauncher = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList Task = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList TcpConnection = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList TcpWrapperConnection = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList TestDBus = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList ThemedIcon = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--data ThreadedSocketServiceRunSignalInfo-instance SignalInfo ThreadedSocketServiceRunSignalInfo where-    type HaskellCallbackType ThreadedSocketServiceRunSignalInfo = ThreadedSocketServiceRunCallback-    connectSignal _ = connectThreadedSocketServiceRun--type instance SignalList ThreadedSocketService = '[ '("event", SocketListenerEventSignalInfo), '("incoming", SocketServiceIncomingSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("run", ThreadedSocketServiceRunSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList TlsBackend = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList TlsCertificate = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList TlsClientConnection = '[ '("accept-certificate", TlsConnectionAcceptCertificateSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--data TlsConnectionAcceptCertificateSignalInfo-instance SignalInfo TlsConnectionAcceptCertificateSignalInfo where-    type HaskellCallbackType TlsConnectionAcceptCertificateSignalInfo = TlsConnectionAcceptCertificateCallback-    connectSignal _ = connectTlsConnectionAcceptCertificate--type instance SignalList TlsConnection = '[ '("accept-certificate", TlsConnectionAcceptCertificateSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList TlsDatabase = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList TlsFileDatabase = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList TlsInteraction = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList TlsPassword = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList TlsServerConnection = '[ '("accept-certificate", TlsConnectionAcceptCertificateSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList UnixConnection = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList UnixCredentialsMessage = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList UnixFDList = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList UnixFDMessage = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList UnixInputStream = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--data UnixMountMonitorMountpointsChangedSignalInfo-instance SignalInfo UnixMountMonitorMountpointsChangedSignalInfo where-    type HaskellCallbackType UnixMountMonitorMountpointsChangedSignalInfo = UnixMountMonitorMountpointsChangedCallback-    connectSignal _ = connectUnixMountMonitorMountpointsChanged--data UnixMountMonitorMountsChangedSignalInfo-instance SignalInfo UnixMountMonitorMountsChangedSignalInfo where-    type HaskellCallbackType UnixMountMonitorMountsChangedSignalInfo = UnixMountMonitorMountsChangedCallback-    connectSignal _ = connectUnixMountMonitorMountsChanged--type instance SignalList UnixMountMonitor = '[ '("mountpoints-changed", UnixMountMonitorMountpointsChangedSignalInfo), '("mounts-changed", UnixMountMonitorMountsChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList UnixOutputStream = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList UnixSocketAddress = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList Vfs = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--data VolumeChangedSignalInfo-instance SignalInfo VolumeChangedSignalInfo where-    type HaskellCallbackType VolumeChangedSignalInfo = VolumeChangedCallback-    connectSignal _ = connectVolumeChanged--data VolumeRemovedSignalInfo-instance SignalInfo VolumeRemovedSignalInfo where-    type HaskellCallbackType VolumeRemovedSignalInfo = VolumeRemovedCallback-    connectSignal _ = connectVolumeRemoved--type instance SignalList Volume = '[ '("changed", VolumeChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("removed", VolumeRemovedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--data VolumeMonitorDriveChangedSignalInfo-instance SignalInfo VolumeMonitorDriveChangedSignalInfo where-    type HaskellCallbackType VolumeMonitorDriveChangedSignalInfo = VolumeMonitorDriveChangedCallback-    connectSignal _ = connectVolumeMonitorDriveChanged--data VolumeMonitorDriveConnectedSignalInfo-instance SignalInfo VolumeMonitorDriveConnectedSignalInfo where-    type HaskellCallbackType VolumeMonitorDriveConnectedSignalInfo = VolumeMonitorDriveConnectedCallback-    connectSignal _ = connectVolumeMonitorDriveConnected--data VolumeMonitorDriveDisconnectedSignalInfo-instance SignalInfo VolumeMonitorDriveDisconnectedSignalInfo where-    type HaskellCallbackType VolumeMonitorDriveDisconnectedSignalInfo = VolumeMonitorDriveDisconnectedCallback-    connectSignal _ = connectVolumeMonitorDriveDisconnected--data VolumeMonitorDriveEjectButtonSignalInfo-instance SignalInfo VolumeMonitorDriveEjectButtonSignalInfo where-    type HaskellCallbackType VolumeMonitorDriveEjectButtonSignalInfo = VolumeMonitorDriveEjectButtonCallback-    connectSignal _ = connectVolumeMonitorDriveEjectButton--data VolumeMonitorDriveStopButtonSignalInfo-instance SignalInfo VolumeMonitorDriveStopButtonSignalInfo where-    type HaskellCallbackType VolumeMonitorDriveStopButtonSignalInfo = VolumeMonitorDriveStopButtonCallback-    connectSignal _ = connectVolumeMonitorDriveStopButton--data VolumeMonitorMountAddedSignalInfo-instance SignalInfo VolumeMonitorMountAddedSignalInfo where-    type HaskellCallbackType VolumeMonitorMountAddedSignalInfo = VolumeMonitorMountAddedCallback-    connectSignal _ = connectVolumeMonitorMountAdded--data VolumeMonitorMountChangedSignalInfo-instance SignalInfo VolumeMonitorMountChangedSignalInfo where-    type HaskellCallbackType VolumeMonitorMountChangedSignalInfo = VolumeMonitorMountChangedCallback-    connectSignal _ = connectVolumeMonitorMountChanged--data VolumeMonitorMountPreUnmountSignalInfo-instance SignalInfo VolumeMonitorMountPreUnmountSignalInfo where-    type HaskellCallbackType VolumeMonitorMountPreUnmountSignalInfo = VolumeMonitorMountPreUnmountCallback-    connectSignal _ = connectVolumeMonitorMountPreUnmount--data VolumeMonitorMountRemovedSignalInfo-instance SignalInfo VolumeMonitorMountRemovedSignalInfo where-    type HaskellCallbackType VolumeMonitorMountRemovedSignalInfo = VolumeMonitorMountRemovedCallback-    connectSignal _ = connectVolumeMonitorMountRemoved--data VolumeMonitorVolumeAddedSignalInfo-instance SignalInfo VolumeMonitorVolumeAddedSignalInfo where-    type HaskellCallbackType VolumeMonitorVolumeAddedSignalInfo = VolumeMonitorVolumeAddedCallback-    connectSignal _ = connectVolumeMonitorVolumeAdded--data VolumeMonitorVolumeChangedSignalInfo-instance SignalInfo VolumeMonitorVolumeChangedSignalInfo where-    type HaskellCallbackType VolumeMonitorVolumeChangedSignalInfo = VolumeMonitorVolumeChangedCallback-    connectSignal _ = connectVolumeMonitorVolumeChanged--data VolumeMonitorVolumeRemovedSignalInfo-instance SignalInfo VolumeMonitorVolumeRemovedSignalInfo where-    type HaskellCallbackType VolumeMonitorVolumeRemovedSignalInfo = VolumeMonitorVolumeRemovedCallback-    connectSignal _ = connectVolumeMonitorVolumeRemoved--type instance SignalList VolumeMonitor = '[ '("drive-changed", VolumeMonitorDriveChangedSignalInfo), '("drive-connected", VolumeMonitorDriveConnectedSignalInfo), '("drive-disconnected", VolumeMonitorDriveDisconnectedSignalInfo), '("drive-eject-button", VolumeMonitorDriveEjectButtonSignalInfo), '("drive-stop-button", VolumeMonitorDriveStopButtonSignalInfo), '("mount-added", VolumeMonitorMountAddedSignalInfo), '("mount-changed", VolumeMonitorMountChangedSignalInfo), '("mount-pre-unmount", VolumeMonitorMountPreUnmountSignalInfo), '("mount-removed", VolumeMonitorMountRemovedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("volume-added", VolumeMonitorVolumeAddedSignalInfo), '("volume-changed", VolumeMonitorVolumeChangedSignalInfo), '("volume-removed", VolumeMonitorVolumeRemovedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList ZlibCompressor = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]--type instance SignalList ZlibDecompressor = '[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)]-
gi-gio.cabal view
@@ -1,6 +1,6 @@ -- Autogenerated, do not edit. name:               gi-gio-version:            0.2.46.10+version:            0.2.46.12 synopsis:           Gio bindings description:        Bindings for Gio, autogenerated by haskell-gi. homepage:           https://github.com/haskell-gi/haskell-gi@@ -14,12 +14,192 @@  library     default-language:   Haskell2010-    exposed-modules:    GI.Gio, GI.GioAttributes, GI.GioSignals+    default-extensions: OverloadedStrings, NegativeLiterals, ConstraintKinds, TypeFamilies, MultiParamTypeClasses, KindSignatures, FlexibleInstances, UndecidableInstances, DataKinds, FlexibleContexts+    other-extensions:   PatternSynonyms ScopedTypeVariables, ViewPatterns+    ghc-options:        -fno-warn-unused-imports -fno-warn-warnings-deprecations+    exposed-modules:    GI.Gio.Types+                        GI.Gio+                        GI.Gio.Callbacks+                        GI.Gio.Constants+                        GI.Gio.Enums+                        GI.Gio.Flags+                        GI.Gio.Functions+                        GI.Gio.Interfaces+                        GI.Gio.Interfaces.Action+                        GI.Gio.Interfaces.ActionGroup+                        GI.Gio.Interfaces.ActionMap+                        GI.Gio.Interfaces.AppInfo+                        GI.Gio.Interfaces.AsyncInitable+                        GI.Gio.Interfaces.AsyncResult+                        GI.Gio.Interfaces.Converter+                        GI.Gio.Interfaces.DBusInterface+                        GI.Gio.Interfaces.DBusObject+                        GI.Gio.Interfaces.DBusObjectManager+                        GI.Gio.Interfaces.DesktopAppInfoLookup+                        GI.Gio.Interfaces.Drive+                        GI.Gio.Interfaces.File+                        GI.Gio.Interfaces.FileDescriptorBased+                        GI.Gio.Interfaces.Icon+                        GI.Gio.Interfaces.Initable+                        GI.Gio.Interfaces.ListModel+                        GI.Gio.Interfaces.LoadableIcon+                        GI.Gio.Interfaces.Mount+                        GI.Gio.Interfaces.NetworkMonitor+                        GI.Gio.Interfaces.PollableInputStream+                        GI.Gio.Interfaces.PollableOutputStream+                        GI.Gio.Interfaces.Proxy+                        GI.Gio.Interfaces.ProxyResolver+                        GI.Gio.Interfaces.RemoteActionGroup+                        GI.Gio.Interfaces.Seekable+                        GI.Gio.Interfaces.SocketConnectable+                        GI.Gio.Interfaces.TlsBackend+                        GI.Gio.Interfaces.TlsClientConnection+                        GI.Gio.Interfaces.TlsFileDatabase+                        GI.Gio.Interfaces.TlsServerConnection+                        GI.Gio.Interfaces.Volume+                        GI.Gio.Objects+                        GI.Gio.Objects.AppInfoMonitor+                        GI.Gio.Objects.AppLaunchContext+                        GI.Gio.Objects.Application+                        GI.Gio.Objects.ApplicationCommandLine+                        GI.Gio.Objects.BufferedInputStream+                        GI.Gio.Objects.BufferedOutputStream+                        GI.Gio.Objects.BytesIcon+                        GI.Gio.Objects.Cancellable+                        GI.Gio.Objects.CharsetConverter+                        GI.Gio.Objects.ConverterInputStream+                        GI.Gio.Objects.ConverterOutputStream+                        GI.Gio.Objects.Credentials+                        GI.Gio.Objects.DBusActionGroup+                        GI.Gio.Objects.DBusAuthObserver+                        GI.Gio.Objects.DBusConnection+                        GI.Gio.Objects.DBusInterfaceSkeleton+                        GI.Gio.Objects.DBusMenuModel+                        GI.Gio.Objects.DBusMessage+                        GI.Gio.Objects.DBusMethodInvocation+                        GI.Gio.Objects.DBusObjectManagerClient+                        GI.Gio.Objects.DBusObjectManagerServer+                        GI.Gio.Objects.DBusObjectProxy+                        GI.Gio.Objects.DBusObjectSkeleton+                        GI.Gio.Objects.DBusProxy+                        GI.Gio.Objects.DBusServer+                        GI.Gio.Objects.DataInputStream+                        GI.Gio.Objects.DataOutputStream+                        GI.Gio.Objects.DesktopAppInfo+                        GI.Gio.Objects.Emblem+                        GI.Gio.Objects.EmblemedIcon+                        GI.Gio.Objects.FileEnumerator+                        GI.Gio.Objects.FileIOStream+                        GI.Gio.Objects.FileIcon+                        GI.Gio.Objects.FileInfo+                        GI.Gio.Objects.FileInputStream+                        GI.Gio.Objects.FileMonitor+                        GI.Gio.Objects.FileOutputStream+                        GI.Gio.Objects.FilenameCompleter+                        GI.Gio.Objects.FilterInputStream+                        GI.Gio.Objects.FilterOutputStream+                        GI.Gio.Objects.IOStream+                        GI.Gio.Objects.InetAddress+                        GI.Gio.Objects.InetAddressMask+                        GI.Gio.Objects.InetSocketAddress+                        GI.Gio.Objects.InputStream+                        GI.Gio.Objects.ListStore+                        GI.Gio.Objects.MemoryInputStream+                        GI.Gio.Objects.MemoryOutputStream+                        GI.Gio.Objects.Menu+                        GI.Gio.Objects.MenuAttributeIter+                        GI.Gio.Objects.MenuItem+                        GI.Gio.Objects.MenuLinkIter+                        GI.Gio.Objects.MenuModel+                        GI.Gio.Objects.MountOperation+                        GI.Gio.Objects.NativeVolumeMonitor+                        GI.Gio.Objects.NetworkAddress+                        GI.Gio.Objects.NetworkService+                        GI.Gio.Objects.Notification+                        GI.Gio.Objects.OutputStream+                        GI.Gio.Objects.Permission+                        GI.Gio.Objects.PropertyAction+                        GI.Gio.Objects.ProxyAddress+                        GI.Gio.Objects.ProxyAddressEnumerator+                        GI.Gio.Objects.Resolver+                        GI.Gio.Objects.Settings+                        GI.Gio.Objects.SimpleAction+                        GI.Gio.Objects.SimpleActionGroup+                        GI.Gio.Objects.SimpleAsyncResult+                        GI.Gio.Objects.SimpleIOStream+                        GI.Gio.Objects.SimplePermission+                        GI.Gio.Objects.SimpleProxyResolver+                        GI.Gio.Objects.Socket+                        GI.Gio.Objects.SocketAddress+                        GI.Gio.Objects.SocketAddressEnumerator+                        GI.Gio.Objects.SocketClient+                        GI.Gio.Objects.SocketConnection+                        GI.Gio.Objects.SocketControlMessage+                        GI.Gio.Objects.SocketListener+                        GI.Gio.Objects.SocketService+                        GI.Gio.Objects.Subprocess+                        GI.Gio.Objects.SubprocessLauncher+                        GI.Gio.Objects.Task+                        GI.Gio.Objects.TcpConnection+                        GI.Gio.Objects.TcpWrapperConnection+                        GI.Gio.Objects.TestDBus+                        GI.Gio.Objects.ThemedIcon+                        GI.Gio.Objects.ThreadedSocketService+                        GI.Gio.Objects.TlsCertificate+                        GI.Gio.Objects.TlsConnection+                        GI.Gio.Objects.TlsDatabase+                        GI.Gio.Objects.TlsInteraction+                        GI.Gio.Objects.TlsPassword+                        GI.Gio.Objects.UnixConnection+                        GI.Gio.Objects.UnixCredentialsMessage+                        GI.Gio.Objects.UnixFDList+                        GI.Gio.Objects.UnixFDMessage+                        GI.Gio.Objects.UnixInputStream+                        GI.Gio.Objects.UnixMountMonitor+                        GI.Gio.Objects.UnixOutputStream+                        GI.Gio.Objects.UnixSocketAddress+                        GI.Gio.Objects.Vfs+                        GI.Gio.Objects.VolumeMonitor+                        GI.Gio.Objects.ZlibCompressor+                        GI.Gio.Objects.ZlibDecompressor+                        GI.Gio.Structs+                        GI.Gio.Structs.ActionEntry+                        GI.Gio.Structs.DBusAnnotationInfo+                        GI.Gio.Structs.DBusArgInfo+                        GI.Gio.Structs.DBusErrorEntry+                        GI.Gio.Structs.DBusInterfaceInfo+                        GI.Gio.Structs.DBusInterfaceVTable+                        GI.Gio.Structs.DBusMethodInfo+                        GI.Gio.Structs.DBusNodeInfo+                        GI.Gio.Structs.DBusPropertyInfo+                        GI.Gio.Structs.DBusSignalInfo+                        GI.Gio.Structs.DBusSubtreeVTable+                        GI.Gio.Structs.FileAttributeInfo+                        GI.Gio.Structs.FileAttributeInfoList+                        GI.Gio.Structs.FileAttributeMatcher+                        GI.Gio.Structs.IOExtension+                        GI.Gio.Structs.IOExtensionPoint+                        GI.Gio.Structs.IOModuleScope+                        GI.Gio.Structs.IOSchedulerJob+                        GI.Gio.Structs.IOStreamAdapter+                        GI.Gio.Structs.InputVector+                        GI.Gio.Structs.NativeSocketAddress+                        GI.Gio.Structs.OutputMessage+                        GI.Gio.Structs.OutputVector+                        GI.Gio.Structs.Resource+                        GI.Gio.Structs.SettingsBackend+                        GI.Gio.Structs.SettingsSchema+                        GI.Gio.Structs.SettingsSchemaKey+                        GI.Gio.Structs.SettingsSchemaSource+                        GI.Gio.Structs.SrvTarget+                        GI.Gio.Structs.StaticResource+                        GI.Gio.Structs.UnixMountEntry+                        GI.Gio.Structs.UnixMountPoint     pkgconfig-depends:  gio-2.0 >= 2.46     build-depends: base >= 4.7 && <5,-        haskell-gi-base >= 0.10 && < 1,-        gi-glib >= 0.2.46.10 && < 0.3,-        gi-gobject >= 0.2.46.10 && < 0.3,+        haskell-gi-base >= 0.12 && < 1,+        gi-glib >= 0.2.46.12 && < 0.2.47,+        gi-gobject >= 0.2.46.12 && < 0.2.47,         bytestring >= 0.10,         containers >= 0.5,         text >= 1.0,